package nav

/*
#include<stdint.h>
#include<stdbool.h>
extern void nav_rcCompactCell_Delete(void * c_this);
extern void nav_rcCompactCell_DeleteArray(void * c_this);
extern unsigned int nav_rcCompactCell_GetBitFieldOfCount(void * c_this);
extern unsigned int nav_rcCompactCell_GetBitFieldOfIndex(void * c_this);
extern void * nav_rcCompactCell_IndexArray(void * c_this,long n);
extern void* nav_NewrcCompactCell();
extern void nav_rcCompactCell_SetFieldOfCount(void * c_this,unsigned int value);
extern void nav_rcCompactCell_SetFieldOfIndex(void * c_this,unsigned int value);
extern void nav_rcCompactHeightfield_Delete(void * c_this);
extern void nav_rcCompactHeightfield_DeleteArray(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToAreas(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToBmax(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToBmin(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToBorderSize(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToCells(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToCh(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToCs(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToDist(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToHeight(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToMaxDistance(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToMaxRegions(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToSpanCount(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToSpans(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToWalkableClimb(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToWalkableHeight(void * c_this);
extern void * nav_rcCompactHeightfield_GetPtrToWidth(void * c_this);
extern void * nav_rcCompactHeightfield_IndexArray(void * c_this,long n);
extern void* nav_NewrcCompactHeightfield();
extern void nav_rcCompactSpan_Delete(void * c_this);
extern void nav_rcCompactSpan_DeleteArray(void * c_this);
extern unsigned int nav_rcCompactSpan_GetBitFieldOfCon(void * c_this);
extern unsigned int nav_rcCompactSpan_GetBitFieldOfH(void * c_this);
extern void * nav_rcCompactSpan_GetPtrToReg(void * c_this);
extern void * nav_rcCompactSpan_GetPtrToY(void * c_this);
extern void * nav_rcCompactSpan_IndexArray(void * c_this,long n);
extern void* nav_NewrcCompactSpan();
extern void nav_rcCompactSpan_SetFieldOfCon(void * c_this,unsigned int value);
extern void nav_rcCompactSpan_SetFieldOfH(void * c_this,unsigned int value);
extern void nav_rcConfig_Delete(void * c_this);
extern void nav_rcConfig_DeleteArray(void * c_this);
extern void * nav_rcConfig_GetPtrToBmax(void * c_this);
extern void * nav_rcConfig_GetPtrToBmin(void * c_this);
extern void * nav_rcConfig_GetPtrToBorderSize(void * c_this);
extern void * nav_rcConfig_GetPtrToCh(void * c_this);
extern void * nav_rcConfig_GetPtrToCs(void * c_this);
extern void * nav_rcConfig_GetPtrToDetailSampleDist(void * c_this);
extern void * nav_rcConfig_GetPtrToDetailSampleMaxError(void * c_this);
extern void * nav_rcConfig_GetPtrToHeight(void * c_this);
extern void * nav_rcConfig_GetPtrToMaxEdgeLen(void * c_this);
extern void * nav_rcConfig_GetPtrToMaxSimplificationError(void * c_this);
extern void * nav_rcConfig_GetPtrToMaxVertsPerPoly(void * c_this);
extern void * nav_rcConfig_GetPtrToMergeRegionArea(void * c_this);
extern void * nav_rcConfig_GetPtrToMinRegionArea(void * c_this);
extern void * nav_rcConfig_GetPtrToTileSize(void * c_this);
extern void * nav_rcConfig_GetPtrToWalkableClimb(void * c_this);
extern void * nav_rcConfig_GetPtrToWalkableHeight(void * c_this);
extern void * nav_rcConfig_GetPtrToWalkableRadius(void * c_this);
extern void * nav_rcConfig_GetPtrToWalkableSlopeAngle(void * c_this);
extern void * nav_rcConfig_GetPtrToWidth(void * c_this);
extern void * nav_rcConfig_IndexArray(void * c_this,long n);
extern void* nav_NewrcConfig();
extern void nav_rcContext_Delete(void * c_this);
extern void nav_rcContext_DeleteArray(void * c_this);
extern void nav_rcContext_enableLog(void * c_this,bool state);
extern void nav_rcContext_enableTimer(void * c_this,bool state);
extern int nav_rcContext_getAccumulatedTime(void * c_this,unsigned int label);
extern void * nav_rcContext_IndexArray(void * c_this,long n);
extern void nav_rcContext_log(void * c_this,unsigned int category,void * format);
extern void* nav_NewrcContext(bool state);
extern void nav_rcContext_resetLog(void * c_this);
extern void nav_rcContext_resetTimers(void * c_this);
extern void nav_rcContext_startTimer(void * c_this,unsigned int label);
extern void nav_rcContext_stopTimer(void * c_this,unsigned int label);
extern void nav_rcContour_Delete(void * c_this);
extern void nav_rcContour_DeleteArray(void * c_this);
extern void * nav_rcContour_GetPtrToArea(void * c_this);
extern void * nav_rcContour_GetPtrToNrverts(void * c_this);
extern void * nav_rcContour_GetPtrToNverts(void * c_this);
extern void * nav_rcContour_GetPtrToReg(void * c_this);
extern void * nav_rcContour_GetPtrToRverts(void * c_this);
extern void * nav_rcContour_GetPtrToVerts(void * c_this);
extern void * nav_rcContour_IndexArray(void * c_this,long n);
extern void* nav_NewrcContour();
extern void nav_rcContourSet_Delete(void * c_this);
extern void nav_rcContourSet_DeleteArray(void * c_this);
extern void * nav_rcContourSet_GetPtrToBmax(void * c_this);
extern void * nav_rcContourSet_GetPtrToBmin(void * c_this);
extern void * nav_rcContourSet_GetPtrToBorderSize(void * c_this);
extern void * nav_rcContourSet_GetPtrToCh(void * c_this);
extern void * nav_rcContourSet_GetPtrToConts(void * c_this);
extern void * nav_rcContourSet_GetPtrToCs(void * c_this);
extern void * nav_rcContourSet_GetPtrToHeight(void * c_this);
extern void * nav_rcContourSet_GetPtrToMaxError(void * c_this);
extern void * nav_rcContourSet_GetPtrToNconts(void * c_this);
extern void * nav_rcContourSet_GetPtrToWidth(void * c_this);
extern void * nav_rcContourSet_IndexArray(void * c_this,long n);
extern void* nav_NewrcContourSet();
extern void nav_rcHeightfield_Delete(void * c_this);
extern void nav_rcHeightfield_DeleteArray(void * c_this);
extern void * nav_rcHeightfield_GetPtrToBmax(void * c_this);
extern void * nav_rcHeightfield_GetPtrToBmin(void * c_this);
extern void * nav_rcHeightfield_GetPtrToCh(void * c_this);
extern void * nav_rcHeightfield_GetPtrToCs(void * c_this);
extern void * nav_rcHeightfield_GetPtrToFreelist(void * c_this);
extern void * nav_rcHeightfield_GetPtrToHeight(void * c_this);
extern void * nav_rcHeightfield_GetPtrToPools(void * c_this);
extern void * nav_rcHeightfield_GetPtrToSpans(void * c_this);
extern void * nav_rcHeightfield_GetPtrToWidth(void * c_this);
extern void * nav_rcHeightfield_IndexArray(void * c_this,long n);
extern void* nav_NewrcHeightfield();
extern void nav_rcHeightfieldLayer_Delete(void * c_this);
extern void nav_rcHeightfieldLayer_DeleteArray(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToAreas(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToBmax(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToBmin(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToCh(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToCons(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToCs(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToHeight(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToHeights(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToHmax(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToHmin(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToMaxx(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToMaxy(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToMinx(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToMiny(void * c_this);
extern void * nav_rcHeightfieldLayer_GetPtrToWidth(void * c_this);
extern void * nav_rcHeightfieldLayer_IndexArray(void * c_this,long n);
extern void* nav_NewrcHeightfieldLayer();
extern void nav_rcHeightfieldLayerSet_Delete(void * c_this);
extern void nav_rcHeightfieldLayerSet_DeleteArray(void * c_this);
extern void * nav_rcHeightfieldLayerSet_GetPtrToLayers(void * c_this);
extern void * nav_rcHeightfieldLayerSet_GetPtrToNlayers(void * c_this);
extern void * nav_rcHeightfieldLayerSet_IndexArray(void * c_this,long n);
extern void* nav_NewrcHeightfieldLayerSet();
extern void nav_rcPolyMesh_Delete(void * c_this);
extern void nav_rcPolyMesh_DeleteArray(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToAreas(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToBmax(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToBmin(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToBorderSize(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToCh(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToCs(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToFlags(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToMaxEdgeError(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToMaxpolys(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToNpolys(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToNverts(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToNvp(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToPolys(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToRegs(void * c_this);
extern void * nav_rcPolyMesh_GetPtrToVerts(void * c_this);
extern void * nav_rcPolyMesh_IndexArray(void * c_this,long n);
extern void* nav_NewrcPolyMesh();
extern void nav_rcPolyMeshDetail_Delete(void * c_this);
extern void nav_rcPolyMeshDetail_DeleteArray(void * c_this);
extern void * nav_rcPolyMeshDetail_GetPtrToMeshes(void * c_this);
extern void * nav_rcPolyMeshDetail_GetPtrToNmeshes(void * c_this);
extern void * nav_rcPolyMeshDetail_GetPtrToNtris(void * c_this);
extern void * nav_rcPolyMeshDetail_GetPtrToNverts(void * c_this);
extern void * nav_rcPolyMeshDetail_GetPtrToTris(void * c_this);
extern void * nav_rcPolyMeshDetail_GetPtrToVerts(void * c_this);
extern void * nav_rcPolyMeshDetail_IndexArray(void * c_this,long n);
extern void* nav_NewrcPolyMeshDetail();
extern void nav_rcScopedTimer_Delete(void * c_this);
extern void nav_rcScopedTimer_DeleteArray(void * c_this);
extern void * nav_rcScopedTimer_IndexArray(void * c_this,long n);
extern void* nav_NewrcScopedTimer(void * ctx,unsigned int label);
extern void nav_rcSpan_Delete(void * c_this);
extern void nav_rcSpan_DeleteArray(void * c_this);
extern unsigned int nav_rcSpan_GetBitFieldOfArea(void * c_this);
extern unsigned int nav_rcSpan_GetBitFieldOfSmax(void * c_this);
extern unsigned int nav_rcSpan_GetBitFieldOfSmin(void * c_this);
extern void * nav_rcSpan_GetPtrToNext(void * c_this);
extern void * nav_rcSpan_IndexArray(void * c_this,long n);
extern void* nav_NewrcSpan();
extern void nav_rcSpan_SetFieldOfArea(void * c_this,unsigned int value);
extern void nav_rcSpan_SetFieldOfSmax(void * c_this,unsigned int value);
extern void nav_rcSpan_SetFieldOfSmin(void * c_this,unsigned int value);
extern void nav_rcSpanPool_Delete(void * c_this);
extern void nav_rcSpanPool_DeleteArray(void * c_this);
extern void * nav_rcSpanPool_GetPtrToItems(void * c_this);
extern void * nav_rcSpanPool_GetPtrToNext(void * c_this);
extern void * nav_rcSpanPool_IndexArray(void * c_this,long n);
extern void* nav_NewrcSpanPool();
extern void * nav_NewRcCompactCellPtrArray(long n);
extern void * nav_NewRcCompactHeightfieldPtrArray(long n);
extern void * nav_NewRcCompactSpanPtrArray(long n);
extern void * nav_NewRcConfigPtrArray(long n);
extern void * nav_NewRcContextPtrArray(long n);
extern void * nav_NewRcContourPtrArray(long n);
extern void * nav_NewRcContourSetPtrArray(long n);
extern void * nav_NewRcHeightfieldLayerPtrArray(long n);
extern void * nav_NewRcHeightfieldLayerSetPtrArray(long n);
extern void * nav_NewRcHeightfieldPtrArray(long n);
extern void * nav_NewRcPolyMeshDetailPtrArray(long n);
extern void * nav_NewRcPolyMeshPtrArray(long n);
extern void * nav_NewRcSpanPoolPtrArray(long n);
extern void * nav_NewRcSpanPtrArray(long n);
extern bool nav_rcAddSpan(void * context,void * heightfield,int x,int z,unsigned short spanMin,unsigned short spanMax,unsigned char areaID,int flagMergeThreshold);
extern void * nav_rcAllocCompactHeightfield();
extern void * nav_rcAllocContourSet();
extern void * nav_rcAllocHeightfield();
extern void * nav_rcAllocHeightfieldLayerSet();
extern void * nav_rcAllocPolyMesh();
extern void * nav_rcAllocPolyMeshDetail();
extern bool nav_rcBuildCompactHeightfield(void * context,int walkableHeight,int walkableClimb,void * heightfield,void * compactHeightfield);
extern bool nav_rcBuildContours(void * ctx,void * chf,float maxError,int maxEdgeLen,void * cset,int buildFlags);
extern bool nav_rcBuildDistanceField(void * ctx,void * chf);
extern bool nav_rcBuildHeightfieldLayers(void * ctx,void * chf,int borderSize,int walkableHeight,void * lset);
extern bool nav_rcBuildLayerRegions(void * ctx,void * chf,int borderSize,int minRegionArea);
extern bool nav_rcBuildPolyMesh(void * ctx,void * cset,int nvp,void * mesh);
extern bool nav_rcBuildPolyMeshDetail(void * ctx,void * mesh,void * chf,float sampleDist,float sampleMaxError,void * dmesh);
extern bool nav_rcBuildRegions(void * ctx,void * chf,int borderSize,int minRegionArea,int mergeRegionArea);
extern bool nav_rcBuildRegionsMonotone(void * ctx,void * chf,int borderSize,int minRegionArea,int mergeRegionArea);
extern void nav_rcCalcBounds(void * verts,int numVerts,void * minBounds,void * maxBounds);
extern void nav_rcCalcGridSize(void * minBounds,void * maxBounds,float cellSize,void * sizeX,void * sizeZ);
extern void nav_rcClearUnwalkableTriangles(void * context,float walkableSlopeAngle,void * verts,int numVerts,void * tris,int numTris,void * triAreaIDs);
extern bool nav_rcCopyPolyMesh(void * ctx,void * src,void * dst);
extern bool nav_rcCreateHeightfield(void * context,void * heightfield,int sizeX,int sizeZ,void * minBounds,void * maxBounds,float cellSize,float cellHeight);
extern bool nav_rcErodeWalkableArea(void * context,int erosionRadius,void * compactHeightfield);
extern void nav_rcFilterLedgeSpans(void * context,int walkableHeight,int walkableClimb,void * heightfield);
extern void nav_rcFilterLowHangingWalkableObstacles(void * context,int walkableClimb,void * heightfield);
extern void nav_rcFilterWalkableLowHeightSpans(void * context,int walkableHeight,void * heightfield);
extern void nav_rcFreeCompactHeightfield(void * compactHeightfield);
extern void nav_rcFreeContourSet(void * contourSet);
extern void nav_rcFreeHeightField(void * heightfield);
extern void nav_rcFreeHeightfieldLayerSet(void * layerSet);
extern void nav_rcFreePolyMesh(void * polyMesh);
extern void nav_rcFreePolyMeshDetail(void * detailMesh);
extern int nav_rcGetCon(void * span,int direction);
extern int nav_rcGetDirForOffset(int offsetX,int offsetZ);
extern int nav_rcGetDirOffsetX(int direction);
extern int nav_rcGetDirOffsetY(int direction);
extern int nav_rcGetHeightFieldSpanCount(void * context,void * heightfield);
extern void nav_rcMarkBoxArea(void * context,void * boxMinBounds,void * boxMaxBounds,unsigned char areaId,void * compactHeightfield);
extern void nav_rcMarkConvexPolyArea(void * context,void * verts,int numVerts,float minY,float maxY,unsigned char areaId,void * compactHeightfield);
extern void nav_rcMarkCylinderArea(void * context,void * position,float radius,float height,unsigned char areaId,void * compactHeightfield);
extern void nav_rcMarkWalkableTriangles(void * context,float walkableSlopeAngle,void * verts,int numVerts,void * tris,int numTris,void * triAreaIDs);
extern bool nav_rcMedianFilterWalkableArea(void * context,void * compactHeightfield);
extern bool nav_rcMergePolyMeshDetails(void * ctx,void * meshes,int nmeshes,void * mesh);
extern bool nav_rcMergePolyMeshes(void * ctx,void * meshes,int nmeshes,void * mesh);
extern int nav_rcOffsetPoly(void * verts,int numVerts,float offset,void * outVerts,int maxOutVerts);
extern bool nav_rcRasterizeTriangle(void * context,void * v0,void * v1,void * v2,unsigned char areaID,void * heightfield,int flagMergeThreshold);
extern bool nav_rcRasterizeTriangles(void * context,void * verts,int numVerts,void * tris,void * triAreaIDs,int numTris,void * heightfield,int flagMergeThreshold);
extern bool nav_rcRasterizeTriangles11(void * context,void * verts,int numVerts,void * tris,void * triAreaIDs,int numTris,void * heightfield,int flagMergeThreshold);
extern bool nav_rcRasterizeTriangles12(void * context,void * verts,void * triAreaIDs,int numTris,void * heightfield,int flagMergeThreshold);
extern void nav_rcSetCon(void * span,int direction,int neighborIndex);
extern float nav_rcSqrt(float x);
extern void nav_rcVadd(void * dest,void * v1,void * v2);
extern void nav_rcVcopy(void * dest,void * v);
extern void nav_rcVcross(void * dest,void * v1,void * v2);
extern float nav_rcVdist(void * v1,void * v2);
extern float nav_rcVdistSqr(void * v1,void * v2);
extern float nav_rcVdot(void * v1,void * v2);
extern void nav_rcVmad(void * dest,void * v1,void * v2,float s);
extern void nav_rcVmax(void * mx,void * v);
extern void nav_rcVmin(void * mn,void * v);
extern void nav_rcVnormalize(void * v);
extern void nav_rcVsub(void * dest,void * v1,void * v2);

*/
import "C"
import "unsafe"
import "gitee.com/hasika/cgo"

var _ unsafe.Pointer
var _ cgo.NotUsed

/*
Provides information on the content of a cell column in a compact heightfield.
*/
type RcCompactCellPtr uintptr

/*
public void Delete()
*/
func (p RcCompactCellPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcCompactCell_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcCompactCellPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcCompactCell_DeleteArray(wrap_this)
}

/*
Number of spans in the column.

public unsigned int GetBitFieldOfCount()
*/
func (p RcCompactCellPtr) GetBitFieldOfCount() uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactCell_GetBitFieldOfCount(wrap_this)
	go_out := uint32(wrap_out)
	return go_out
}

/*
Index to the first span in the column.

public unsigned int GetBitFieldOfIndex()
*/
func (p RcCompactCellPtr) GetBitFieldOfIndex() uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactCell_GetBitFieldOfIndex(wrap_this)
	go_out := uint32(wrap_out)
	return go_out
}

/*
rcCompactCell * IndexArray(long n)
*/
func (p RcCompactCellPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactCell_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public rcCompactCell()
*/
func NewRcCompactCell() cgo.GoManagedPtr[RcCompactCellPtr] {
	wrap_out := C.nav_NewrcCompactCell()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcCompactCellPtr]](uintptr(wrap_out))
	return go_out
}

/*
Number of spans in the column.

public void SetFieldOfCount(unsigned int value)
*/
func (p RcCompactCellPtr) SetFieldOfCount(value uint32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_value C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_value = (C.uint)(value)
	C.nav_rcCompactCell_SetFieldOfCount(wrap_this, wrap_arg_value)
}

/*
Index to the first span in the column.

public void SetFieldOfIndex(unsigned int value)
*/
func (p RcCompactCellPtr) SetFieldOfIndex(value uint32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_value C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_value = (C.uint)(value)
	C.nav_rcCompactCell_SetFieldOfIndex(wrap_this, wrap_arg_value)
}

/*
A compact, static heightfield representing unobstructed space.

	recast
*/
type RcCompactHeightfieldPtr uintptr

/*
public void Delete()
*/
func (p RcCompactHeightfieldPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcCompactHeightfield_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcCompactHeightfieldPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcCompactHeightfield_DeleteArray(wrap_this)
}

/*
Array containing area id data. [Size: #spanCount]

public unsigned char * * GetPtrToAreas()
*/
func (p RcCompactHeightfieldPtr) GetPtrToAreas() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToAreas(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum bounds in world space. [(x, y, z)]

public float(*)[3] GetPtrToBmax()
*/
func (p RcCompactHeightfieldPtr) GetPtrToBmax() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToBmax(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The minimum bounds in world space. [(x, y, z)]

public float(*)[3] GetPtrToBmin()
*/
func (p RcCompactHeightfieldPtr) GetPtrToBmin() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToBmin(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The AABB border size used during the build of the field. (See: rcConfig::borderSize)

public int * GetPtrToBorderSize()
*/
func (p RcCompactHeightfieldPtr) GetPtrToBorderSize() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToBorderSize(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Array of cells. [Size: #width*#height]

public rcCompactCell * * GetPtrToCells()
*/
func (p RcCompactHeightfieldPtr) GetPtrToCells() *RcCompactCellPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToCells(wrap_this)
	go_out := (*RcCompactCellPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The height of each cell. (The minimum increment along the y-axis.)

public float * GetPtrToCh()
*/
func (p RcCompactHeightfieldPtr) GetPtrToCh() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToCh(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The size of each cell. (On the xz-plane.)

public float * GetPtrToCs()
*/
func (p RcCompactHeightfieldPtr) GetPtrToCs() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToCs(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Array containing border distance data. [Size: #spanCount]

public unsigned short * * GetPtrToDist()
*/
func (p RcCompactHeightfieldPtr) GetPtrToDist() **uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToDist(wrap_this)
	go_out := (**uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The height of the heightfield. (Along the z-axis in cell units.)

public int * GetPtrToHeight()
*/
func (p RcCompactHeightfieldPtr) GetPtrToHeight() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToHeight(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum distance value of any span within the field.

public unsigned short * GetPtrToMaxDistance()
*/
func (p RcCompactHeightfieldPtr) GetPtrToMaxDistance() *uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToMaxDistance(wrap_this)
	go_out := (*uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum region id of any span within the field.

public unsigned short * GetPtrToMaxRegions()
*/
func (p RcCompactHeightfieldPtr) GetPtrToMaxRegions() *uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToMaxRegions(wrap_this)
	go_out := (*uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of spans in the heightfield.

public int * GetPtrToSpanCount()
*/
func (p RcCompactHeightfieldPtr) GetPtrToSpanCount() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToSpanCount(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Array of spans. [Size: #spanCount]

public rcCompactSpan * * GetPtrToSpans()
*/
func (p RcCompactHeightfieldPtr) GetPtrToSpans() *RcCompactSpanPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToSpans(wrap_this)
	go_out := (*RcCompactSpanPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The walkable climb used during the build of the field. (See: rcConfig::walkableClimb)

public int * GetPtrToWalkableClimb()
*/
func (p RcCompactHeightfieldPtr) GetPtrToWalkableClimb() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToWalkableClimb(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The walkable height used during the build of the field.  (See: rcConfig::walkableHeight)

public int * GetPtrToWalkableHeight()
*/
func (p RcCompactHeightfieldPtr) GetPtrToWalkableHeight() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToWalkableHeight(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The width of the heightfield. (Along the x-axis in cell units.)

public int * GetPtrToWidth()
*/
func (p RcCompactHeightfieldPtr) GetPtrToWidth() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_GetPtrToWidth(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
rcCompactHeightfield * IndexArray(long n)
*/
func (p RcCompactHeightfieldPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactHeightfield_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public rcCompactHeightfield()
*/
func NewRcCompactHeightfield() cgo.GoManagedPtr[RcCompactHeightfieldPtr] {
	wrap_out := C.nav_NewrcCompactHeightfield()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcCompactHeightfieldPtr]](uintptr(wrap_out))
	return go_out
}

/*
Represents a span of unobstructed space within a compact heightfield.
*/
type RcCompactSpanPtr uintptr

/*
public void Delete()
*/
func (p RcCompactSpanPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcCompactSpan_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcCompactSpanPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcCompactSpan_DeleteArray(wrap_this)
}

/*
Packed neighbor connection data.

public unsigned int GetBitFieldOfCon()
*/
func (p RcCompactSpanPtr) GetBitFieldOfCon() uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactSpan_GetBitFieldOfCon(wrap_this)
	go_out := uint32(wrap_out)
	return go_out
}

/*
The height of the span.  (Measured from #y.)

public unsigned int GetBitFieldOfH()
*/
func (p RcCompactSpanPtr) GetBitFieldOfH() uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactSpan_GetBitFieldOfH(wrap_this)
	go_out := uint32(wrap_out)
	return go_out
}

/*
The id of the region the span belongs to. (Or zero if not in a region.)

public unsigned short * GetPtrToReg()
*/
func (p RcCompactSpanPtr) GetPtrToReg() *uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactSpan_GetPtrToReg(wrap_this)
	go_out := (*uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The lower extent of the span. (Measured from the heightfield's base.)

public unsigned short * GetPtrToY()
*/
func (p RcCompactSpanPtr) GetPtrToY() *uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactSpan_GetPtrToY(wrap_this)
	go_out := (*uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
rcCompactSpan * IndexArray(long n)
*/
func (p RcCompactSpanPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcCompactSpan_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public rcCompactSpan()
*/
func NewRcCompactSpan() cgo.GoManagedPtr[RcCompactSpanPtr] {
	wrap_out := C.nav_NewrcCompactSpan()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcCompactSpanPtr]](uintptr(wrap_out))
	return go_out
}

/*
Packed neighbor connection data.

public void SetFieldOfCon(unsigned int value)
*/
func (p RcCompactSpanPtr) SetFieldOfCon(value uint32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_value C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_value = (C.uint)(value)
	C.nav_rcCompactSpan_SetFieldOfCon(wrap_this, wrap_arg_value)
}

/*
The height of the span.  (Measured from #y.)

public void SetFieldOfH(unsigned int value)
*/
func (p RcCompactSpanPtr) SetFieldOfH(value uint32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_value C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_value = (C.uint)(value)
	C.nav_rcCompactSpan_SetFieldOfH(wrap_this, wrap_arg_value)
}

/*
Specifies a configuration to use when performing Recast builds.

	recast
*/
type RcConfigPtr uintptr

/*
public void Delete()
*/
func (p RcConfigPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcConfig_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcConfigPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcConfig_DeleteArray(wrap_this)
}

/*
The maximum bounds of the field's AABB. [(x, y, z)] [Units: wu]

public float(*)[3] GetPtrToBmax()
*/
func (p RcConfigPtr) GetPtrToBmax() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToBmax(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The minimum bounds of the field's AABB. [(x, y, z)] [Units: wu]

public float(*)[3] GetPtrToBmin()
*/
func (p RcConfigPtr) GetPtrToBmin() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToBmin(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The size of the non-navigable border around the heightfield. [Limit: >=0] [Units: vx]

public int * GetPtrToBorderSize()
*/
func (p RcConfigPtr) GetPtrToBorderSize() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToBorderSize(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The y-axis cell size to use for fields. [Limit: > 0] [Units: wu]

public float * GetPtrToCh()
*/
func (p RcConfigPtr) GetPtrToCh() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToCh(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The xz-plane cell size to use for fields. [Limit: > 0] [Units: wu]

public float * GetPtrToCs()
*/
func (p RcConfigPtr) GetPtrToCs() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToCs(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Sets the sampling distance to use when generating the detail mesh.
(For height detail only.) [Limits: 0 or >= 0.9] [Units: wu]

public float * GetPtrToDetailSampleDist()
*/
func (p RcConfigPtr) GetPtrToDetailSampleDist() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToDetailSampleDist(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum distance the detail mesh surface should deviate from heightfield
data. (For height detail only.) [Limit: >=0] [Units: wu]

public float * GetPtrToDetailSampleMaxError()
*/
func (p RcConfigPtr) GetPtrToDetailSampleMaxError() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToDetailSampleMaxError(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The height of the field along the z-axis. [Limit: >= 0] [Units: vx]

public int * GetPtrToHeight()
*/
func (p RcConfigPtr) GetPtrToHeight() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToHeight(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum allowed length for contour edges along the border of the mesh. [Limit: >=0] [Units: vx]

public int * GetPtrToMaxEdgeLen()
*/
func (p RcConfigPtr) GetPtrToMaxEdgeLen() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToMaxEdgeLen(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum distance a simplified contour's border edges should deviate
the original raw contour. [Limit: >=0] [Units: vx]

public float * GetPtrToMaxSimplificationError()
*/
func (p RcConfigPtr) GetPtrToMaxSimplificationError() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToMaxSimplificationError(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum number of vertices allowed for polygons generated during the
contour to polygon conversion process. [Limit: >= 3]

public int * GetPtrToMaxVertsPerPoly()
*/
func (p RcConfigPtr) GetPtrToMaxVertsPerPoly() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToMaxVertsPerPoly(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Any regions with a span count smaller than this value will, if possible,
be merged with larger regions. [Limit: >=0] [Units: vx]

public int * GetPtrToMergeRegionArea()
*/
func (p RcConfigPtr) GetPtrToMergeRegionArea() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToMergeRegionArea(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The minimum number of cells allowed to form isolated island areas. [Limit: >=0] [Units: vx]

public int * GetPtrToMinRegionArea()
*/
func (p RcConfigPtr) GetPtrToMinRegionArea() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToMinRegionArea(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The widthheight size of tile's on the xz-plane. [Limit: >= 0] [Units: vx]

public int * GetPtrToTileSize()
*/
func (p RcConfigPtr) GetPtrToTileSize() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToTileSize(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Maximum ledge height that is considered to still be traversable. [Limit: >=0] [Units: vx]

public int * GetPtrToWalkableClimb()
*/
func (p RcConfigPtr) GetPtrToWalkableClimb() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToWalkableClimb(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Minimum floor to 'ceiling' height that will still allow the floor area to
be considered walkable. [Limit: >= 3] [Units: vx]

public int * GetPtrToWalkableHeight()
*/
func (p RcConfigPtr) GetPtrToWalkableHeight() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToWalkableHeight(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The distance to erodeshrink the walkable area of the heightfield away from
obstructions.  [Limit: >=0] [Units: vx]

public int * GetPtrToWalkableRadius()
*/
func (p RcConfigPtr) GetPtrToWalkableRadius() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToWalkableRadius(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum slope that is considered walkable. [Limits: 0
<
= value
<
90] [Units: Degrees]

public float * GetPtrToWalkableSlopeAngle()
*/
func (p RcConfigPtr) GetPtrToWalkableSlopeAngle() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToWalkableSlopeAngle(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The width of the field along the x-axis. [Limit: >= 0] [Units: vx]

public int * GetPtrToWidth()
*/
func (p RcConfigPtr) GetPtrToWidth() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_GetPtrToWidth(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
rcConfig * IndexArray(long n)
*/
func (p RcConfigPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcConfig_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public rcConfig()
*/
func NewRcConfig() cgo.GoManagedPtr[RcConfigPtr] {
	wrap_out := C.nav_NewrcConfig()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcConfigPtr]](uintptr(wrap_out))
	return go_out
}

/*
Provides an interface for optional logging and performance tracking of the Recast
build process.
This class does not provide logging or timer functionality on its
own.  Both must be provided by a concrete implementation
by overriding the protected member functions.  Also, this class does not
provide an interface for extracting log messages. (Only adding them.)
So concrete implementations must provide one.
If no logging or timers are required, just pass an instance of this
class through the Recast build process.

	recast
*/
type RcContextPtr uintptr

/*
public virtual void Delete()
*/
func (p RcContextPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcContext_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcContextPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcContext_DeleteArray(wrap_this)
}

/*
Enables or disables logging.

@param state TRUE if logging should be enabled.

public void enableLog(bool state)
*/
func (p RcContextPtr) EnableLog(state bool) {
	var wrap_this unsafe.Pointer
	var wrap_arg_state C._Bool
	wrap_this = unsafe.Pointer(p)
	wrap_arg_state = (C._Bool)(state)
	C.nav_rcContext_enableLog(wrap_this, wrap_arg_state)
}

/*
Enables or disables the performance timers.

@param state TRUE if timers should be enabled.

public void enableTimer(bool state)
*/
func (p RcContextPtr) EnableTimer(state bool) {
	var wrap_this unsafe.Pointer
	var wrap_arg_state C._Bool
	wrap_this = unsafe.Pointer(p)
	wrap_arg_state = (C._Bool)(state)
	C.nav_rcContext_enableTimer(wrap_this, wrap_arg_state)
}

/*
Returns the total accumulated time of the specified performance timer.

@param label The category of the timer.
@return The accumulated time of the timer, or -1 if timers are disabled or the timer has never been started.

public int getAccumulatedTime(rcTimerLabel const label) const
*/
func (p RcContextPtr) GetAccumulatedTime(label EnumRcTimerLabel) int32 {
	var wrap_this unsafe.Pointer
	var wrap_arg_label C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_label = (C.uint)(label)
	wrap_out := C.nav_rcContext_getAccumulatedTime(wrap_this, wrap_arg_label)
	go_out := int32(wrap_out)
	return go_out
}

/*
rcContext * IndexArray(long n)
*/
func (p RcContextPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContext_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Logs a message.
Example:

@code   Where ctx is an instance of rcContext and filepath is a char array.

	ctx->log(RC_LOG_ERROR, "buildTiledNavigation: Could not load '%s'", filepath);

@endcode

@param category The category of the message.
@param format The message.

public void log(rcLogCategory const category, char const * format, ...)
*/
func (p RcContextPtr) Log(category EnumRcLogCategory, format *int8) {
	var wrap_this unsafe.Pointer
	var wrap_arg_category C.uint
	var wrap_arg_format unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_arg_category = (C.uint)(category)
	wrap_arg_format = (unsafe.Pointer)(format)
	C.nav_rcContext_log(wrap_this, wrap_arg_category, wrap_arg_format)
}

/*
Constructor.

@param state TRUE if the logging and performance timers should be enabled.  [Default: true]

public rcContext(bool state=1)
*/
func NewRcContext(state bool) cgo.GoManagedPtr[RcContextPtr] {
	var wrap_arg_state C._Bool
	wrap_arg_state = (C._Bool)(state)
	wrap_out := C.nav_NewrcContext(wrap_arg_state)
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcContextPtr]](uintptr(wrap_out))
	return go_out
}

/*
Clears all log entries.

public void resetLog()
*/
func (p RcContextPtr) ResetLog() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcContext_resetLog(wrap_this)
}

/*
Clears all performance timers. (Resets all to unused.)

public void resetTimers()
*/
func (p RcContextPtr) ResetTimers() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcContext_resetTimers(wrap_this)
}

/*
Starts the specified performance timer.

@param label The category of the timer.

public void startTimer(rcTimerLabel const label)
*/
func (p RcContextPtr) StartTimer(label EnumRcTimerLabel) {
	var wrap_this unsafe.Pointer
	var wrap_arg_label C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_label = (C.uint)(label)
	C.nav_rcContext_startTimer(wrap_this, wrap_arg_label)
}

/*
Stops the specified performance timer.

@param label The category of the timer.

public void stopTimer(rcTimerLabel const label)
*/
func (p RcContextPtr) StopTimer(label EnumRcTimerLabel) {
	var wrap_this unsafe.Pointer
	var wrap_arg_label C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_label = (C.uint)(label)
	C.nav_rcContext_stopTimer(wrap_this, wrap_arg_label)
}

/*
Represents a simple, non-overlapping contour in field space.
*/
type RcContourPtr uintptr

/*
public void Delete()
*/
func (p RcContourPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcContour_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcContourPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcContour_DeleteArray(wrap_this)
}

/*
The area id of the contour.

public unsigned char * GetPtrToArea()
*/
func (p RcContourPtr) GetPtrToArea() *uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContour_GetPtrToArea(wrap_this)
	go_out := (*uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of vertices in the raw contour.

public int * GetPtrToNrverts()
*/
func (p RcContourPtr) GetPtrToNrverts() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContour_GetPtrToNrverts(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of vertices in the simplified contour.

public int * GetPtrToNverts()
*/
func (p RcContourPtr) GetPtrToNverts() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContour_GetPtrToNverts(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The region id of the contour.

public unsigned short * GetPtrToReg()
*/
func (p RcContourPtr) GetPtrToReg() *uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContour_GetPtrToReg(wrap_this)
	go_out := (*uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Raw contour vertex and connection data. [Size: 4 * #nrverts]

public int * * GetPtrToRverts()
*/
func (p RcContourPtr) GetPtrToRverts() **int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContour_GetPtrToRverts(wrap_this)
	go_out := (**int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Simplified contour vertex and connection data. [Size: 4 * #nverts]

public int * * GetPtrToVerts()
*/
func (p RcContourPtr) GetPtrToVerts() **int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContour_GetPtrToVerts(wrap_this)
	go_out := (**int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
rcContour * IndexArray(long n)
*/
func (p RcContourPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContour_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public rcContour()
*/
func NewRcContour() cgo.GoManagedPtr[RcContourPtr] {
	wrap_out := C.nav_NewrcContour()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcContourPtr]](uintptr(wrap_out))
	return go_out
}

/*
Represents a group of related contours.

	recast
*/
type RcContourSetPtr uintptr

/*
public void Delete()
*/
func (p RcContourSetPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcContourSet_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcContourSetPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcContourSet_DeleteArray(wrap_this)
}

/*
The maximum bounds in world space. [(x, y, z)]

public float(*)[3] GetPtrToBmax()
*/
func (p RcContourSetPtr) GetPtrToBmax() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContourSet_GetPtrToBmax(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The minimum bounds in world space. [(x, y, z)]

public float(*)[3] GetPtrToBmin()
*/
func (p RcContourSetPtr) GetPtrToBmin() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContourSet_GetPtrToBmin(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The AABB border size used to generate the source data from which the contours were derived.

public int * GetPtrToBorderSize()
*/
func (p RcContourSetPtr) GetPtrToBorderSize() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContourSet_GetPtrToBorderSize(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The height of each cell. (The minimum increment along the y-axis.)

public float * GetPtrToCh()
*/
func (p RcContourSetPtr) GetPtrToCh() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContourSet_GetPtrToCh(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
An array of the contours in the set. [Size: #nconts]

public rcContour * * GetPtrToConts()
*/
func (p RcContourSetPtr) GetPtrToConts() *RcContourPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContourSet_GetPtrToConts(wrap_this)
	go_out := (*RcContourPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The size of each cell. (On the xz-plane.)

public float * GetPtrToCs()
*/
func (p RcContourSetPtr) GetPtrToCs() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContourSet_GetPtrToCs(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The height of the set. (Along the z-axis in cell units.)

public int * GetPtrToHeight()
*/
func (p RcContourSetPtr) GetPtrToHeight() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContourSet_GetPtrToHeight(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The max edge error that this contour set was simplified with.

public float * GetPtrToMaxError()
*/
func (p RcContourSetPtr) GetPtrToMaxError() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContourSet_GetPtrToMaxError(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of contours in the set.

public int * GetPtrToNconts()
*/
func (p RcContourSetPtr) GetPtrToNconts() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContourSet_GetPtrToNconts(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The width of the set. (Along the x-axis in cell units.)

public int * GetPtrToWidth()
*/
func (p RcContourSetPtr) GetPtrToWidth() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContourSet_GetPtrToWidth(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
rcContourSet * IndexArray(long n)
*/
func (p RcContourSetPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcContourSet_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public rcContourSet()
*/
func NewRcContourSet() cgo.GoManagedPtr[RcContourSetPtr] {
	wrap_out := C.nav_NewrcContourSet()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcContourSetPtr]](uintptr(wrap_out))
	return go_out
}

/*
A dynamic heightfield representing obstructed space.

	recast
*/
type RcHeightfieldPtr uintptr

/*
public void Delete()
*/
func (p RcHeightfieldPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcHeightfield_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcHeightfieldPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcHeightfield_DeleteArray(wrap_this)
}

/*
The maximum bounds in world space. [(x, y, z)]

public float(*)[3] GetPtrToBmax()
*/
func (p RcHeightfieldPtr) GetPtrToBmax() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfield_GetPtrToBmax(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The minimum bounds in world space. [(x, y, z)]

public float(*)[3] GetPtrToBmin()
*/
func (p RcHeightfieldPtr) GetPtrToBmin() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfield_GetPtrToBmin(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The height of each cell. (The minimum increment along the y-axis.)

public float * GetPtrToCh()
*/
func (p RcHeightfieldPtr) GetPtrToCh() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfield_GetPtrToCh(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The size of each cell. (On the xz-plane.)

public float * GetPtrToCs()
*/
func (p RcHeightfieldPtr) GetPtrToCs() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfield_GetPtrToCs(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The next free span.

public rcSpan * * GetPtrToFreelist()
*/
func (p RcHeightfieldPtr) GetPtrToFreelist() *RcSpanPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfield_GetPtrToFreelist(wrap_this)
	go_out := (*RcSpanPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The height of the heightfield. (Along the z-axis in cell units.)

public int * GetPtrToHeight()
*/
func (p RcHeightfieldPtr) GetPtrToHeight() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfield_GetPtrToHeight(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Linked list of span pools.

public rcSpanPool * * GetPtrToPools()
*/
func (p RcHeightfieldPtr) GetPtrToPools() *RcSpanPoolPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfield_GetPtrToPools(wrap_this)
	go_out := (*RcSpanPoolPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Heightfield of spans (width*height).

public rcSpan * * * GetPtrToSpans()
*/
func (p RcHeightfieldPtr) GetPtrToSpans() **RcSpanPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfield_GetPtrToSpans(wrap_this)
	go_out := (**RcSpanPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The width of the heightfield. (Along the x-axis in cell units.)

public int * GetPtrToWidth()
*/
func (p RcHeightfieldPtr) GetPtrToWidth() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfield_GetPtrToWidth(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
rcHeightfield * IndexArray(long n)
*/
func (p RcHeightfieldPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfield_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public rcHeightfield()
*/
func NewRcHeightfield() cgo.GoManagedPtr[RcHeightfieldPtr] {
	wrap_out := C.nav_NewrcHeightfield()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcHeightfieldPtr]](uintptr(wrap_out))
	return go_out
}

/*
Represents a heightfield layer within a layer set.

@see rcHeightfieldLayerSet
*/
type RcHeightfieldLayerPtr uintptr

/*
public void Delete()
*/
func (p RcHeightfieldLayerPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcHeightfieldLayer_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcHeightfieldLayerPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcHeightfieldLayer_DeleteArray(wrap_this)
}

/*
Area ids. [Size: Same as #heights]

public unsigned char * * GetPtrToAreas()
*/
func (p RcHeightfieldLayerPtr) GetPtrToAreas() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToAreas(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum bounds in world space. [(x, y, z)]

public float(*)[3] GetPtrToBmax()
*/
func (p RcHeightfieldLayerPtr) GetPtrToBmax() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToBmax(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The minimum bounds in world space. [(x, y, z)]

public float(*)[3] GetPtrToBmin()
*/
func (p RcHeightfieldLayerPtr) GetPtrToBmin() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToBmin(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The height of each cell. (The minimum increment along the y-axis.)

public float * GetPtrToCh()
*/
func (p RcHeightfieldLayerPtr) GetPtrToCh() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToCh(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Packed neighbor connection information. [Size: Same as #heights]

public unsigned char * * GetPtrToCons()
*/
func (p RcHeightfieldLayerPtr) GetPtrToCons() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToCons(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The size of each cell. (On the xz-plane.)

public float * GetPtrToCs()
*/
func (p RcHeightfieldLayerPtr) GetPtrToCs() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToCs(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The height of the heightfield. (Along the z-axis in cell units.)

public int * GetPtrToHeight()
*/
func (p RcHeightfieldLayerPtr) GetPtrToHeight() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToHeight(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The heightfield. [Size: width * height]

public unsigned char * * GetPtrToHeights()
*/
func (p RcHeightfieldLayerPtr) GetPtrToHeights() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToHeights(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum height bounds of usable data. (Along the y-axis.)

public int * GetPtrToHmax()
*/
func (p RcHeightfieldLayerPtr) GetPtrToHmax() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToHmax(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The minimum height bounds of usable data. (Along the y-axis.)

public int * GetPtrToHmin()
*/
func (p RcHeightfieldLayerPtr) GetPtrToHmin() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToHmin(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum x-bounds of usable data.

public int * GetPtrToMaxx()
*/
func (p RcHeightfieldLayerPtr) GetPtrToMaxx() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToMaxx(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum y-bounds of usable data. (Along the z-axis.)

public int * GetPtrToMaxy()
*/
func (p RcHeightfieldLayerPtr) GetPtrToMaxy() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToMaxy(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The minimum x-bounds of usable data.

public int * GetPtrToMinx()
*/
func (p RcHeightfieldLayerPtr) GetPtrToMinx() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToMinx(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The minimum y-bounds of usable data. (Along the z-axis.)

public int * GetPtrToMiny()
*/
func (p RcHeightfieldLayerPtr) GetPtrToMiny() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToMiny(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The width of the heightfield. (Along the x-axis in cell units.)

public int * GetPtrToWidth()
*/
func (p RcHeightfieldLayerPtr) GetPtrToWidth() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_GetPtrToWidth(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
rcHeightfieldLayer * IndexArray(long n)
*/
func (p RcHeightfieldLayerPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayer_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public rcHeightfieldLayer()
*/
func NewRcHeightfieldLayer() cgo.GoManagedPtr[RcHeightfieldLayerPtr] {
	wrap_out := C.nav_NewrcHeightfieldLayer()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcHeightfieldLayerPtr]](uintptr(wrap_out))
	return go_out
}

/*
Represents a set of heightfield layers.

	recast

@see rcAllocHeightfieldLayerSet, rcFreeHeightfieldLayerSet
*/
type RcHeightfieldLayerSetPtr uintptr

/*
public void Delete()
*/
func (p RcHeightfieldLayerSetPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcHeightfieldLayerSet_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcHeightfieldLayerSetPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcHeightfieldLayerSet_DeleteArray(wrap_this)
}

/*
The layers in the set. [Size: #nlayers]

public rcHeightfieldLayer * * GetPtrToLayers()
*/
func (p RcHeightfieldLayerSetPtr) GetPtrToLayers() *RcHeightfieldLayerPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayerSet_GetPtrToLayers(wrap_this)
	go_out := (*RcHeightfieldLayerPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of layers in the set.

public int * GetPtrToNlayers()
*/
func (p RcHeightfieldLayerSetPtr) GetPtrToNlayers() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayerSet_GetPtrToNlayers(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
rcHeightfieldLayerSet * IndexArray(long n)
*/
func (p RcHeightfieldLayerSetPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcHeightfieldLayerSet_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public rcHeightfieldLayerSet()
*/
func NewRcHeightfieldLayerSet() cgo.GoManagedPtr[RcHeightfieldLayerSetPtr] {
	wrap_out := C.nav_NewrcHeightfieldLayerSet()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcHeightfieldLayerSetPtr]](uintptr(wrap_out))
	return go_out
}

/*
Represents a polygon mesh suitable for use in building a navigation mesh.

	recast
*/
type RcPolyMeshPtr uintptr

/*
public void Delete()
*/
func (p RcPolyMeshPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcPolyMesh_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcPolyMeshPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcPolyMesh_DeleteArray(wrap_this)
}

/*
The area id assigned to each polygon. [Length: #maxpolys]

public unsigned char * * GetPtrToAreas()
*/
func (p RcPolyMeshPtr) GetPtrToAreas() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToAreas(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum bounds in world space. [(x, y, z)]

public float(*)[3] GetPtrToBmax()
*/
func (p RcPolyMeshPtr) GetPtrToBmax() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToBmax(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The minimum bounds in world space. [(x, y, z)]

public float(*)[3] GetPtrToBmin()
*/
func (p RcPolyMeshPtr) GetPtrToBmin() *[3]float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToBmin(wrap_this)
	go_out := (*[3]float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The AABB border size used to generate the source data from which the mesh was derived.

public int * GetPtrToBorderSize()
*/
func (p RcPolyMeshPtr) GetPtrToBorderSize() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToBorderSize(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The height of each cell. (The minimum increment along the y-axis.)

public float * GetPtrToCh()
*/
func (p RcPolyMeshPtr) GetPtrToCh() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToCh(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The size of each cell. (On the xz-plane.)

public float * GetPtrToCs()
*/
func (p RcPolyMeshPtr) GetPtrToCs() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToCs(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The user defined flags for each polygon. [Length: #maxpolys]

public unsigned short * * GetPtrToFlags()
*/
func (p RcPolyMeshPtr) GetPtrToFlags() **uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToFlags(wrap_this)
	go_out := (**uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The max error of the polygon edges in the mesh.

public float * GetPtrToMaxEdgeError()
*/
func (p RcPolyMeshPtr) GetPtrToMaxEdgeError() *float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToMaxEdgeError(wrap_this)
	go_out := (*float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of allocated polygons.

public int * GetPtrToMaxpolys()
*/
func (p RcPolyMeshPtr) GetPtrToMaxpolys() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToMaxpolys(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of polygons.

public int * GetPtrToNpolys()
*/
func (p RcPolyMeshPtr) GetPtrToNpolys() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToNpolys(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of vertices.

public int * GetPtrToNverts()
*/
func (p RcPolyMeshPtr) GetPtrToNverts() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToNverts(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The maximum number of vertices per polygon.

public int * GetPtrToNvp()
*/
func (p RcPolyMeshPtr) GetPtrToNvp() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToNvp(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
Polygon and neighbor data. [Length: #maxpolys * 2 * #nvp]

public unsigned short * * GetPtrToPolys()
*/
func (p RcPolyMeshPtr) GetPtrToPolys() **uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToPolys(wrap_this)
	go_out := (**uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The region id assigned to each polygon. [Length: #maxpolys]

public unsigned short * * GetPtrToRegs()
*/
func (p RcPolyMeshPtr) GetPtrToRegs() **uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToRegs(wrap_this)
	go_out := (**uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The mesh vertices. [Form: (x, y, z) * #nverts]

public unsigned short * * GetPtrToVerts()
*/
func (p RcPolyMeshPtr) GetPtrToVerts() **uint16 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_GetPtrToVerts(wrap_this)
	go_out := (**uint16)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
rcPolyMesh * IndexArray(long n)
*/
func (p RcPolyMeshPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMesh_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public rcPolyMesh()
*/
func NewRcPolyMesh() cgo.GoManagedPtr[RcPolyMeshPtr] {
	wrap_out := C.nav_NewrcPolyMesh()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcPolyMeshPtr]](uintptr(wrap_out))
	return go_out
}

/*
Contains triangle meshes that represent detailed height data associated
with the polygons in its associated polygon mesh object.

	recast
*/
type RcPolyMeshDetailPtr uintptr

/*
public void Delete()
*/
func (p RcPolyMeshDetailPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcPolyMeshDetail_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcPolyMeshDetailPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcPolyMeshDetail_DeleteArray(wrap_this)
}

/*
The sub-mesh data. [Size: 4*#nmeshes]

public unsigned int * * GetPtrToMeshes()
*/
func (p RcPolyMeshDetailPtr) GetPtrToMeshes() **uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMeshDetail_GetPtrToMeshes(wrap_this)
	go_out := (**uint32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of sub-meshes defined by #meshes.

public int * GetPtrToNmeshes()
*/
func (p RcPolyMeshDetailPtr) GetPtrToNmeshes() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMeshDetail_GetPtrToNmeshes(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of triangles in #tris.

public int * GetPtrToNtris()
*/
func (p RcPolyMeshDetailPtr) GetPtrToNtris() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMeshDetail_GetPtrToNtris(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The number of vertices in #verts.

public int * GetPtrToNverts()
*/
func (p RcPolyMeshDetailPtr) GetPtrToNverts() *int32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMeshDetail_GetPtrToNverts(wrap_this)
	go_out := (*int32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The mesh triangles. [Size: 4*#ntris]

public unsigned char * * GetPtrToTris()
*/
func (p RcPolyMeshDetailPtr) GetPtrToTris() **uint8 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMeshDetail_GetPtrToTris(wrap_this)
	go_out := (**uint8)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
The mesh vertices. [Size: 3*#nverts]

public float * * GetPtrToVerts()
*/
func (p RcPolyMeshDetailPtr) GetPtrToVerts() **float32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMeshDetail_GetPtrToVerts(wrap_this)
	go_out := (**float32)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
rcPolyMeshDetail * IndexArray(long n)
*/
func (p RcPolyMeshDetailPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcPolyMeshDetail_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public rcPolyMeshDetail()
*/
func NewRcPolyMeshDetail() cgo.GoManagedPtr[RcPolyMeshDetailPtr] {
	wrap_out := C.nav_NewrcPolyMeshDetail()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcPolyMeshDetailPtr]](uintptr(wrap_out))
	return go_out
}

/*
A helper to first start a timer and then stop it when this helper goes out of scope.

@see rcContext
*/
type RcScopedTimerPtr uintptr

/*
public void Delete()
*/
func (p RcScopedTimerPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcScopedTimer_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcScopedTimerPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcScopedTimer_DeleteArray(wrap_this)
}

/*
rcScopedTimer * IndexArray(long n)
*/
func (p RcScopedTimerPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcScopedTimer_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
Constructs an instance and starts the timer.

@param ctx The context to use.
@param label The category of the timer.

public rcScopedTimer(rcContext * ctx, rcTimerLabel const label)
*/
func NewRcScopedTimer(ctx RcContextPtr, label EnumRcTimerLabel) cgo.GoManagedPtr[RcScopedTimerPtr] {
	var wrap_arg_ctx unsafe.Pointer
	var wrap_arg_label C.uint
	wrap_arg_ctx = (unsafe.Pointer)(ctx)
	wrap_arg_label = (C.uint)(label)
	wrap_out := C.nav_NewrcScopedTimer(wrap_arg_ctx, wrap_arg_label)
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcScopedTimerPtr]](uintptr(wrap_out))
	return go_out
}

/*
Represents a span in a heightfield.

@see rcHeightfield
*/
type RcSpanPtr uintptr

/*
public void Delete()
*/
func (p RcSpanPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcSpan_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcSpanPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcSpan_DeleteArray(wrap_this)
}

/*
The area id assigned to the span.

public unsigned int GetBitFieldOfArea()
*/
func (p RcSpanPtr) GetBitFieldOfArea() uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcSpan_GetBitFieldOfArea(wrap_this)
	go_out := uint32(wrap_out)
	return go_out
}

/*
The upper limit of the span. [Limit:
<
= #RC_SPAN_MAX_HEIGHT]

public unsigned int GetBitFieldOfSmax()
*/
func (p RcSpanPtr) GetBitFieldOfSmax() uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcSpan_GetBitFieldOfSmax(wrap_this)
	go_out := uint32(wrap_out)
	return go_out
}

/*
The lower limit of the span. [Limit:
<
#smax]

public unsigned int GetBitFieldOfSmin()
*/
func (p RcSpanPtr) GetBitFieldOfSmin() uint32 {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcSpan_GetBitFieldOfSmin(wrap_this)
	go_out := uint32(wrap_out)
	return go_out
}

/*
The next span higher up in column.

public rcSpan * * GetPtrToNext()
*/
func (p RcSpanPtr) GetPtrToNext() *RcSpanPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcSpan_GetPtrToNext(wrap_this)
	go_out := (*RcSpanPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
rcSpan * IndexArray(long n)
*/
func (p RcSpanPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcSpan_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public rcSpan()
*/
func NewRcSpan() cgo.GoManagedPtr[RcSpanPtr] {
	wrap_out := C.nav_NewrcSpan()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcSpanPtr]](uintptr(wrap_out))
	return go_out
}

/*
The area id assigned to the span.

public void SetFieldOfArea(unsigned int value)
*/
func (p RcSpanPtr) SetFieldOfArea(value uint32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_value C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_value = (C.uint)(value)
	C.nav_rcSpan_SetFieldOfArea(wrap_this, wrap_arg_value)
}

/*
The upper limit of the span. [Limit:
<
= #RC_SPAN_MAX_HEIGHT]

public void SetFieldOfSmax(unsigned int value)
*/
func (p RcSpanPtr) SetFieldOfSmax(value uint32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_value C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_value = (C.uint)(value)
	C.nav_rcSpan_SetFieldOfSmax(wrap_this, wrap_arg_value)
}

/*
The lower limit of the span. [Limit:
<
#smax]

public void SetFieldOfSmin(unsigned int value)
*/
func (p RcSpanPtr) SetFieldOfSmin(value uint32) {
	var wrap_this unsafe.Pointer
	var wrap_arg_value C.uint
	wrap_this = unsafe.Pointer(p)
	wrap_arg_value = (C.uint)(value)
	C.nav_rcSpan_SetFieldOfSmin(wrap_this, wrap_arg_value)
}

/*
A memory pool used for quick allocation of spans within a heightfield.

@see rcHeightfield
*/
type RcSpanPoolPtr uintptr

/*
public void Delete()
*/
func (p RcSpanPoolPtr) Delete() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcSpanPool_Delete(wrap_this)
}

/*
void DeleteArray()
*/
func (p RcSpanPoolPtr) DeleteArray() {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	C.nav_rcSpanPool_DeleteArray(wrap_this)
}

/*
Array of spans in the pool.

public rcSpan(*)[2048] GetPtrToItems()
*/
func (p RcSpanPoolPtr) GetPtrToItems() RcSpanPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcSpanPool_GetPtrToItems(wrap_this)
	go_out := cgo.MakePtr[RcSpanPtr](uintptr(wrap_out))
	return go_out
}

/*
The next span pool.

public rcSpanPool * * GetPtrToNext()
*/
func (p RcSpanPoolPtr) GetPtrToNext() *RcSpanPoolPtr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcSpanPool_GetPtrToNext(wrap_this)
	go_out := (*RcSpanPoolPtr)(unsafe.Pointer(wrap_out))
	return go_out
}

/*
rcSpanPool * IndexArray(long n)
*/
func (p RcSpanPoolPtr) IndexArray(n int) uintptr {
	var wrap_this unsafe.Pointer
	wrap_this = unsafe.Pointer(p)
	wrap_out := C.nav_rcSpanPool_IndexArray(wrap_this, C.long(n))
	go_out := uintptr(wrap_out)
	return go_out
}

/*
public rcSpanPool()
*/
func NewRcSpanPool() cgo.GoManagedPtr[RcSpanPoolPtr] {
	wrap_out := C.nav_NewrcSpanPool()
	go_out := cgo.MakePtr[cgo.GoManagedPtr[RcSpanPoolPtr]](uintptr(wrap_out))
	return go_out
}

/*
rcCompactCell * NewRcCompactCellPtrArray(long n)
*/
func NewRcCompactCellPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcCompactCellPtr]] {
	wrap_out := C.nav_NewRcCompactCellPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcCompactCellPtr]]](uintptr(wrap_out))
	return go_out
}

/*
rcCompactHeightfield * NewRcCompactHeightfieldPtrArray(long n)
*/
func NewRcCompactHeightfieldPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcCompactHeightfieldPtr]] {
	wrap_out := C.nav_NewRcCompactHeightfieldPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcCompactHeightfieldPtr]]](uintptr(wrap_out))
	return go_out
}

/*
rcCompactSpan * NewRcCompactSpanPtrArray(long n)
*/
func NewRcCompactSpanPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcCompactSpanPtr]] {
	wrap_out := C.nav_NewRcCompactSpanPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcCompactSpanPtr]]](uintptr(wrap_out))
	return go_out
}

/*
rcConfig * NewRcConfigPtrArray(long n)
*/
func NewRcConfigPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcConfigPtr]] {
	wrap_out := C.nav_NewRcConfigPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcConfigPtr]]](uintptr(wrap_out))
	return go_out
}

/*
rcContext * NewRcContextPtrArray(long n)
*/
func NewRcContextPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcContextPtr]] {
	wrap_out := C.nav_NewRcContextPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcContextPtr]]](uintptr(wrap_out))
	return go_out
}

/*
rcContour * NewRcContourPtrArray(long n)
*/
func NewRcContourPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcContourPtr]] {
	wrap_out := C.nav_NewRcContourPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcContourPtr]]](uintptr(wrap_out))
	return go_out
}

/*
rcContourSet * NewRcContourSetPtrArray(long n)
*/
func NewRcContourSetPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcContourSetPtr]] {
	wrap_out := C.nav_NewRcContourSetPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcContourSetPtr]]](uintptr(wrap_out))
	return go_out
}

/*
rcHeightfieldLayer * NewRcHeightfieldLayerPtrArray(long n)
*/
func NewRcHeightfieldLayerPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcHeightfieldLayerPtr]] {
	wrap_out := C.nav_NewRcHeightfieldLayerPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcHeightfieldLayerPtr]]](uintptr(wrap_out))
	return go_out
}

/*
rcHeightfieldLayerSet * NewRcHeightfieldLayerSetPtrArray(long n)
*/
func NewRcHeightfieldLayerSetPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcHeightfieldLayerSetPtr]] {
	wrap_out := C.nav_NewRcHeightfieldLayerSetPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcHeightfieldLayerSetPtr]]](uintptr(wrap_out))
	return go_out
}

/*
rcHeightfield * NewRcHeightfieldPtrArray(long n)
*/
func NewRcHeightfieldPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcHeightfieldPtr]] {
	wrap_out := C.nav_NewRcHeightfieldPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcHeightfieldPtr]]](uintptr(wrap_out))
	return go_out
}

/*
rcPolyMeshDetail * NewRcPolyMeshDetailPtrArray(long n)
*/
func NewRcPolyMeshDetailPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcPolyMeshDetailPtr]] {
	wrap_out := C.nav_NewRcPolyMeshDetailPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcPolyMeshDetailPtr]]](uintptr(wrap_out))
	return go_out
}

/*
rcPolyMesh * NewRcPolyMeshPtrArray(long n)
*/
func NewRcPolyMeshPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcPolyMeshPtr]] {
	wrap_out := C.nav_NewRcPolyMeshPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcPolyMeshPtr]]](uintptr(wrap_out))
	return go_out
}

/*
rcSpanPool * NewRcSpanPoolPtrArray(long n)
*/
func NewRcSpanPoolPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcSpanPoolPtr]] {
	wrap_out := C.nav_NewRcSpanPoolPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcSpanPoolPtr]]](uintptr(wrap_out))
	return go_out
}

/*
rcSpan * NewRcSpanPtrArray(long n)
*/
func NewRcSpanPtrArray(n int) cgo.GoManagedPtr[cgo.Array[RcSpanPtr]] {
	wrap_out := C.nav_NewRcSpanPtrArray(C.long(n))
	go_out := cgo.MakePtr[cgo.GoManagedPtr[cgo.Array[RcSpanPtr]]](uintptr(wrap_out))
	return go_out
}

/*
Adds a span to the specified heightfield.
The span addition can be set to favor flags. If the span is merged to
another span and the new @p spanMax is within @p flagMergeThreshold units
from the existing span, the span flags are merged.

	recast

@param context The build context to use during the operation.
@param heightfield An initialized heightfield.
@param x The column x index where the span is to be added.
[Limits: 0
<
= value
<
rcHeightfield::width]
@param z The column z index where the span is to be added.
[Limits: 0
<
= value
<
rcHeightfield::height]
@param spanMin The minimum height of the span. [Limit:
<
@p spanMax] [Units: vx]
@param spanMax The maximum height of the span. [Limit:
<
= #RC_SPAN_MAX_HEIGHT] [Units: vx]
@param areaID The area id of the span. [Limit:
<
= #RC_WALKABLE_AREA)
@param flagMergeThreshold The merge threshold. [Limit: >= 0] [Units: vx]
@returns True if the operation completed successfully.

bool rcAddSpan(rcContext * context, rcHeightfield& heightfield, int x, int z, unsigned short spanMin, unsigned short spanMax, unsigned char areaID, int flagMergeThreshold)
*/
func RcAddSpan(context RcContextPtr, heightfield RcHeightfieldPtr, x int32, z int32, spanMin uint16, spanMax uint16, areaID uint8, flagMergeThreshold int32) bool {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_heightfield unsafe.Pointer
	var wrap_arg_x C.int
	var wrap_arg_z C.int
	var wrap_arg_spanMin C.ushort
	var wrap_arg_spanMax C.ushort
	var wrap_arg_areaID C.uchar
	var wrap_arg_flagMergeThreshold C.int
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_heightfield = (unsafe.Pointer)(heightfield)
	wrap_arg_x = (C.int)(x)
	wrap_arg_z = (C.int)(z)
	wrap_arg_spanMin = (C.ushort)(spanMin)
	wrap_arg_spanMax = (C.ushort)(spanMax)
	wrap_arg_areaID = (C.uchar)(areaID)
	wrap_arg_flagMergeThreshold = (C.int)(flagMergeThreshold)
	wrap_out := C.nav_rcAddSpan(wrap_arg_context, wrap_arg_heightfield, wrap_arg_x, wrap_arg_z, wrap_arg_spanMin, wrap_arg_spanMax, wrap_arg_areaID, wrap_arg_flagMergeThreshold)
	go_out := bool(wrap_out)
	return go_out
}

/*
Allocates a compact heightfield object using the Recast allocator.

@return A compact heightfield that is ready for initialization, or null on failure.

	recast

@see rcBuildCompactHeightfield, rcFreeCompactHeightfield

rcCompactHeightfield * rcAllocCompactHeightfield()
*/
func RcAllocCompactHeightfield() RcCompactHeightfieldPtr {
	wrap_out := C.nav_rcAllocCompactHeightfield()
	go_out := cgo.MakePtr[RcCompactHeightfieldPtr](uintptr(wrap_out))
	return go_out
}

/*
Allocates a contour set object using the Recast allocator.

@return A contour set that is ready for initialization, or null on failure.

	recast

@see rcBuildContours, rcFreeContourSet

rcContourSet * rcAllocContourSet()
*/
func RcAllocContourSet() RcContourSetPtr {
	wrap_out := C.nav_rcAllocContourSet()
	go_out := cgo.MakePtr[RcContourSetPtr](uintptr(wrap_out))
	return go_out
}

/*
Allocates a heightfield object using the Recast allocator.

@return A heightfield that is ready for initialization, or null on failure.

	recast

@see rcCreateHeightfield, rcFreeHeightField

rcHeightfield * rcAllocHeightfield()
*/
func RcAllocHeightfield() RcHeightfieldPtr {
	wrap_out := C.nav_rcAllocHeightfield()
	go_out := cgo.MakePtr[RcHeightfieldPtr](uintptr(wrap_out))
	return go_out
}

/*
Allocates a heightfield layer set using the Recast allocator.

@return A heightfield layer set that is ready for initialization, or null on failure.

	recast

@see rcBuildHeightfieldLayers, rcFreeHeightfieldLayerSet

rcHeightfieldLayerSet * rcAllocHeightfieldLayerSet()
*/
func RcAllocHeightfieldLayerSet() RcHeightfieldLayerSetPtr {
	wrap_out := C.nav_rcAllocHeightfieldLayerSet()
	go_out := cgo.MakePtr[RcHeightfieldLayerSetPtr](uintptr(wrap_out))
	return go_out
}

/*
Allocates a polygon mesh object using the Recast allocator.

@return A polygon mesh that is ready for initialization, or null on failure.

	recast

@see rcBuildPolyMesh, rcFreePolyMesh

rcPolyMesh * rcAllocPolyMesh()
*/
func RcAllocPolyMesh() RcPolyMeshPtr {
	wrap_out := C.nav_rcAllocPolyMesh()
	go_out := cgo.MakePtr[RcPolyMeshPtr](uintptr(wrap_out))
	return go_out
}

/*
Allocates a detail mesh object using the Recast allocator.

@return A detail mesh that is ready for initialization, or null on failure.

	recast

@see rcBuildPolyMeshDetail, rcFreePolyMeshDetail

rcPolyMeshDetail * rcAllocPolyMeshDetail()
*/
func RcAllocPolyMeshDetail() RcPolyMeshDetailPtr {
	wrap_out := C.nav_rcAllocPolyMeshDetail()
	go_out := cgo.MakePtr[RcPolyMeshDetailPtr](uintptr(wrap_out))
	return go_out
}

/*
Builds a compact heightfield representing open space, from a heightfield representing solid space.
This is just the beginning of the process of fully building a compact heightfield.
Various filters may be applied, then the distance field and regions built.
E.g: #rcBuildDistanceField and #rcBuildRegions
See the #rcConfig documentation for more information on the configuration parameters.

@see rcAllocCompactHeightfield, rcHeightfield, rcCompactHeightfield, rcConfig

	recast

@param context The build context to use during the operation.
@param walkableHeight Minimum floor to 'ceiling' height that will still allow the floor area
to be considered walkable. [Limit: >= 3] [Units: vx]
@param walkableClimb Maximum ledge height that is considered to still be traversable.
[Limit: >=0] [Units: vx]
@param heightfield The heightfield to be compacted.
@param compactHeightfield The resulting compact heightfield. (Must be pre-allocated.)
@returns True if the operation completed successfully.

bool rcBuildCompactHeightfield(rcContext * context, int walkableHeight, int walkableClimb, rcHeightfield const& heightfield, rcCompactHeightfield& compactHeightfield)
*/
func RcBuildCompactHeightfield(context RcContextPtr, walkableHeight int32, walkableClimb int32, heightfield RcHeightfieldPtr, compactHeightfield RcCompactHeightfieldPtr) bool {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_walkableHeight C.int
	var wrap_arg_walkableClimb C.int
	var wrap_arg_heightfield unsafe.Pointer
	var wrap_arg_compactHeightfield unsafe.Pointer
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_walkableHeight = (C.int)(walkableHeight)
	wrap_arg_walkableClimb = (C.int)(walkableClimb)
	wrap_arg_heightfield = (unsafe.Pointer)(heightfield)
	wrap_arg_compactHeightfield = (unsafe.Pointer)(compactHeightfield)
	wrap_out := C.nav_rcBuildCompactHeightfield(wrap_arg_context, wrap_arg_walkableHeight, wrap_arg_walkableClimb, wrap_arg_heightfield, wrap_arg_compactHeightfield)
	go_out := bool(wrap_out)
	return go_out
}

/*
Builds a contour set from the region outlines in the provided compact heightfield.

	recast

@param ctx The build context to use during the operation.
@param chf A fully built compact heightfield.
@param maxError The maximum distance a simplified contour's border edges should deviate
the original raw contour. [Limit: >=0] [Units: wu]
@param maxEdgeLen The maximum allowed length for contour edges along the border of the mesh.
[Limit: >=0] [Units: vx]
@param cset The resulting contour set. (Must be pre-allocated.)
@param buildFlags The build flags. (See: #rcBuildContoursFlags)
@returns True if the operation completed successfully.

bool rcBuildContours(rcContext * ctx, rcCompactHeightfield const& chf, float maxError, int maxEdgeLen, rcContourSet& cset, int buildFlags=1)
*/
func RcBuildContours(ctx RcContextPtr, chf RcCompactHeightfieldPtr, maxError float32, maxEdgeLen int32, cset RcContourSetPtr, buildFlags int32) bool {
	var wrap_arg_ctx unsafe.Pointer
	var wrap_arg_chf unsafe.Pointer
	var wrap_arg_maxError C.float
	var wrap_arg_maxEdgeLen C.int
	var wrap_arg_cset unsafe.Pointer
	var wrap_arg_buildFlags C.int
	wrap_arg_ctx = (unsafe.Pointer)(ctx)
	wrap_arg_chf = (unsafe.Pointer)(chf)
	wrap_arg_maxError = (C.float)(maxError)
	wrap_arg_maxEdgeLen = (C.int)(maxEdgeLen)
	wrap_arg_cset = (unsafe.Pointer)(cset)
	wrap_arg_buildFlags = (C.int)(buildFlags)
	wrap_out := C.nav_rcBuildContours(wrap_arg_ctx, wrap_arg_chf, wrap_arg_maxError, wrap_arg_maxEdgeLen, wrap_arg_cset, wrap_arg_buildFlags)
	go_out := bool(wrap_out)
	return go_out
}

/*
Builds the distance field for the specified compact heightfield.

	recast

@param ctx The build context to use during the operation.
@param chf A populated compact heightfield.
@returns True if the operation completed successfully.

bool rcBuildDistanceField(rcContext * ctx, rcCompactHeightfield& chf)
*/
func RcBuildDistanceField(ctx RcContextPtr, chf RcCompactHeightfieldPtr) bool {
	var wrap_arg_ctx unsafe.Pointer
	var wrap_arg_chf unsafe.Pointer
	wrap_arg_ctx = (unsafe.Pointer)(ctx)
	wrap_arg_chf = (unsafe.Pointer)(chf)
	wrap_out := C.nav_rcBuildDistanceField(wrap_arg_ctx, wrap_arg_chf)
	go_out := bool(wrap_out)
	return go_out
}

/*
Builds a layer set from the specified compact heightfield.

	recast

@param ctx The build context to use during the operation.
@param chf A fully built compact heightfield.
@param borderSize The size of the non-navigable border around the heightfield. [Limit: >=0]
[Units: vx]
@param walkableHeight Minimum floor to 'ceiling' height that will still allow the floor area
to be considered walkable. [Limit: >= 3] [Units: vx]
@param lset The resulting layer set. (Must be pre-allocated.)
@returns True if the operation completed successfully.

bool rcBuildHeightfieldLayers(rcContext * ctx, rcCompactHeightfield const& chf, int borderSize, int walkableHeight, rcHeightfieldLayerSet& lset)
*/
func RcBuildHeightfieldLayers(ctx RcContextPtr, chf RcCompactHeightfieldPtr, borderSize int32, walkableHeight int32, lset RcHeightfieldLayerSetPtr) bool {
	var wrap_arg_ctx unsafe.Pointer
	var wrap_arg_chf unsafe.Pointer
	var wrap_arg_borderSize C.int
	var wrap_arg_walkableHeight C.int
	var wrap_arg_lset unsafe.Pointer
	wrap_arg_ctx = (unsafe.Pointer)(ctx)
	wrap_arg_chf = (unsafe.Pointer)(chf)
	wrap_arg_borderSize = (C.int)(borderSize)
	wrap_arg_walkableHeight = (C.int)(walkableHeight)
	wrap_arg_lset = (unsafe.Pointer)(lset)
	wrap_out := C.nav_rcBuildHeightfieldLayers(wrap_arg_ctx, wrap_arg_chf, wrap_arg_borderSize, wrap_arg_walkableHeight, wrap_arg_lset)
	go_out := bool(wrap_out)
	return go_out
}

/*
Builds region data for the heightfield by partitioning the heightfield in non-overlapping layers.

	recast

@param ctx The build context to use during the operation.
@param chf A populated compact heightfield.
@param borderSize The size of the non-navigable border around the heightfield.
[Limit: >=0] [Units: vx]
@param minRegionArea The minimum number of cells allowed to form isolated island areas.
[Limit: >=0] [Units: vx].
@returns True if the operation completed successfully.

bool rcBuildLayerRegions(rcContext * ctx, rcCompactHeightfield& chf, int borderSize, int minRegionArea)
*/
func RcBuildLayerRegions(ctx RcContextPtr, chf RcCompactHeightfieldPtr, borderSize int32, minRegionArea int32) bool {
	var wrap_arg_ctx unsafe.Pointer
	var wrap_arg_chf unsafe.Pointer
	var wrap_arg_borderSize C.int
	var wrap_arg_minRegionArea C.int
	wrap_arg_ctx = (unsafe.Pointer)(ctx)
	wrap_arg_chf = (unsafe.Pointer)(chf)
	wrap_arg_borderSize = (C.int)(borderSize)
	wrap_arg_minRegionArea = (C.int)(minRegionArea)
	wrap_out := C.nav_rcBuildLayerRegions(wrap_arg_ctx, wrap_arg_chf, wrap_arg_borderSize, wrap_arg_minRegionArea)
	go_out := bool(wrap_out)
	return go_out
}

/*
Builds a polygon mesh from the provided contours.

	recast

@param ctx The build context to use during the operation.
@param cset A fully built contour set.
@param nvp The maximum number of vertices allowed for polygons generated during the
contour to polygon conversion process. [Limit: >= 3]
@param mesh The resulting polygon mesh. (Must be re-allocated.)
@returns True if the operation completed successfully.

bool rcBuildPolyMesh(rcContext * ctx, rcContourSet const& cset, int const nvp, rcPolyMesh& mesh)
*/
func RcBuildPolyMesh(ctx RcContextPtr, cset RcContourSetPtr, nvp int32, mesh RcPolyMeshPtr) bool {
	var wrap_arg_ctx unsafe.Pointer
	var wrap_arg_cset unsafe.Pointer
	var wrap_arg_nvp C.int
	var wrap_arg_mesh unsafe.Pointer
	wrap_arg_ctx = (unsafe.Pointer)(ctx)
	wrap_arg_cset = (unsafe.Pointer)(cset)
	wrap_arg_nvp = (C.int)(nvp)
	wrap_arg_mesh = (unsafe.Pointer)(mesh)
	wrap_out := C.nav_rcBuildPolyMesh(wrap_arg_ctx, wrap_arg_cset, wrap_arg_nvp, wrap_arg_mesh)
	go_out := bool(wrap_out)
	return go_out
}

/*
Builds a detail mesh from the provided polygon mesh.

	recast

@param ctx The build context to use during the operation.
@param mesh A fully built polygon mesh.
@param chf The compact heightfield used to build the polygon mesh.
@param sampleDist Sets the distance to use when sampling the heightfield. [Limit: >=0] [Units: wu]
@param sampleMaxError The maximum distance the detail mesh surface should deviate from
heightfield data. [Limit: >=0] [Units: wu]
@param dmesh The resulting detail mesh.  (Must be pre-allocated.)
@returns True if the operation completed successfully.

bool rcBuildPolyMeshDetail(rcContext * ctx, rcPolyMesh const& mesh, rcCompactHeightfield const& chf, float sampleDist, float sampleMaxError, rcPolyMeshDetail& dmesh)
*/
func RcBuildPolyMeshDetail(ctx RcContextPtr, mesh RcPolyMeshPtr, chf RcCompactHeightfieldPtr, sampleDist float32, sampleMaxError float32, dmesh RcPolyMeshDetailPtr) bool {
	var wrap_arg_ctx unsafe.Pointer
	var wrap_arg_mesh unsafe.Pointer
	var wrap_arg_chf unsafe.Pointer
	var wrap_arg_sampleDist C.float
	var wrap_arg_sampleMaxError C.float
	var wrap_arg_dmesh unsafe.Pointer
	wrap_arg_ctx = (unsafe.Pointer)(ctx)
	wrap_arg_mesh = (unsafe.Pointer)(mesh)
	wrap_arg_chf = (unsafe.Pointer)(chf)
	wrap_arg_sampleDist = (C.float)(sampleDist)
	wrap_arg_sampleMaxError = (C.float)(sampleMaxError)
	wrap_arg_dmesh = (unsafe.Pointer)(dmesh)
	wrap_out := C.nav_rcBuildPolyMeshDetail(wrap_arg_ctx, wrap_arg_mesh, wrap_arg_chf, wrap_arg_sampleDist, wrap_arg_sampleMaxError, wrap_arg_dmesh)
	go_out := bool(wrap_out)
	return go_out
}

/*
Builds region data for the heightfield using watershed partitioning.

	recast

@param ctx The build context to use during the operation.
@param chf A populated compact heightfield.
@param borderSize The size of the non-navigable border around the heightfield.
[Limit: >=0] [Units: vx]
@param minRegionArea The minimum number of cells allowed to form isolated island areas.
[Limit: >=0] [Units: vx].
@param mergeRegionArea Any regions with a span count smaller than this value will, if possible,
be merged with larger regions. [Limit: >=0] [Units: vx]
@returns True if the operation completed successfully.

bool rcBuildRegions(rcContext * ctx, rcCompactHeightfield& chf, int borderSize, int minRegionArea, int mergeRegionArea)
*/
func RcBuildRegions(ctx RcContextPtr, chf RcCompactHeightfieldPtr, borderSize int32, minRegionArea int32, mergeRegionArea int32) bool {
	var wrap_arg_ctx unsafe.Pointer
	var wrap_arg_chf unsafe.Pointer
	var wrap_arg_borderSize C.int
	var wrap_arg_minRegionArea C.int
	var wrap_arg_mergeRegionArea C.int
	wrap_arg_ctx = (unsafe.Pointer)(ctx)
	wrap_arg_chf = (unsafe.Pointer)(chf)
	wrap_arg_borderSize = (C.int)(borderSize)
	wrap_arg_minRegionArea = (C.int)(minRegionArea)
	wrap_arg_mergeRegionArea = (C.int)(mergeRegionArea)
	wrap_out := C.nav_rcBuildRegions(wrap_arg_ctx, wrap_arg_chf, wrap_arg_borderSize, wrap_arg_minRegionArea, wrap_arg_mergeRegionArea)
	go_out := bool(wrap_out)
	return go_out
}

/*
Builds region data for the heightfield using simple monotone partitioning.

	recast

@param ctx The build context to use during the operation.
@param chf A populated compact heightfield.
@param borderSize The size of the non-navigable border around the heightfield.
[Limit: >=0] [Units: vx]
@param minRegionArea The minimum number of cells allowed to form isolated island areas.
[Limit: >=0] [Units: vx].
@param mergeRegionArea Any regions with a span count smaller than this value will, if possible,
be merged with larger regions. [Limit: >=0] [Units: vx]
@returns True if the operation completed successfully.

bool rcBuildRegionsMonotone(rcContext * ctx, rcCompactHeightfield& chf, int borderSize, int minRegionArea, int mergeRegionArea)
*/
func RcBuildRegionsMonotone(ctx RcContextPtr, chf RcCompactHeightfieldPtr, borderSize int32, minRegionArea int32, mergeRegionArea int32) bool {
	var wrap_arg_ctx unsafe.Pointer
	var wrap_arg_chf unsafe.Pointer
	var wrap_arg_borderSize C.int
	var wrap_arg_minRegionArea C.int
	var wrap_arg_mergeRegionArea C.int
	wrap_arg_ctx = (unsafe.Pointer)(ctx)
	wrap_arg_chf = (unsafe.Pointer)(chf)
	wrap_arg_borderSize = (C.int)(borderSize)
	wrap_arg_minRegionArea = (C.int)(minRegionArea)
	wrap_arg_mergeRegionArea = (C.int)(mergeRegionArea)
	wrap_out := C.nav_rcBuildRegionsMonotone(wrap_arg_ctx, wrap_arg_chf, wrap_arg_borderSize, wrap_arg_minRegionArea, wrap_arg_mergeRegionArea)
	go_out := bool(wrap_out)
	return go_out
}

/*
Calculates the bounding box of an array of vertices.

	recast

@param verts An array of vertices. [(x, y, z) * @p nv]
@param numVerts The number of vertices in the @p verts array.
@param minBounds The minimum bounds of the AABB. [(x, y, z)] [Units: wu]
@param maxBounds The maximum bounds of the AABB. [(x, y, z)] [Units: wu]

void rcCalcBounds(float const * verts, int numVerts, float * minBounds, float * maxBounds)
*/
func RcCalcBounds(verts *float32, numVerts int32, minBounds *float32, maxBounds *float32) {
	var wrap_arg_verts unsafe.Pointer
	var wrap_arg_numVerts C.int
	var wrap_arg_minBounds unsafe.Pointer
	var wrap_arg_maxBounds unsafe.Pointer
	wrap_arg_verts = (unsafe.Pointer)(verts)
	wrap_arg_numVerts = (C.int)(numVerts)
	wrap_arg_minBounds = (unsafe.Pointer)(minBounds)
	wrap_arg_maxBounds = (unsafe.Pointer)(maxBounds)
	C.nav_rcCalcBounds(wrap_arg_verts, wrap_arg_numVerts, wrap_arg_minBounds, wrap_arg_maxBounds)
}

/*
Calculates the grid size based on the bounding box and grid cell size.

	recast

@param minBounds The minimum bounds of the AABB. [(x, y, z)] [Units: wu]
@param maxBounds The maximum bounds of the AABB. [(x, y, z)] [Units: wu]
@param cellSize The xz-plane cell size. [Limit: > 0] [Units: wu]
@param sizeX The width along the x-axis. [Limit: >= 0] [Units: vx]
@param sizeZ The height along the z-axis. [Limit: >= 0] [Units: vx]

void rcCalcGridSize(float const * minBounds, float const * maxBounds, float cellSize, int * sizeX, int * sizeZ)
*/
func RcCalcGridSize(minBounds *float32, maxBounds *float32, cellSize float32, sizeX *int32, sizeZ *int32) {
	var wrap_arg_minBounds unsafe.Pointer
	var wrap_arg_maxBounds unsafe.Pointer
	var wrap_arg_cellSize C.float
	var wrap_arg_sizeX unsafe.Pointer
	var wrap_arg_sizeZ unsafe.Pointer
	wrap_arg_minBounds = (unsafe.Pointer)(minBounds)
	wrap_arg_maxBounds = (unsafe.Pointer)(maxBounds)
	wrap_arg_cellSize = (C.float)(cellSize)
	wrap_arg_sizeX = (unsafe.Pointer)(sizeX)
	wrap_arg_sizeZ = (unsafe.Pointer)(sizeZ)
	C.nav_rcCalcGridSize(wrap_arg_minBounds, wrap_arg_maxBounds, wrap_arg_cellSize, wrap_arg_sizeX, wrap_arg_sizeZ)
}

/*
Sets the area id of all triangles with a slope greater than or equal to the specified value to #RC_NULL_AREA.
Only sets the area id's for the un-walkable triangles.  Does not alter the
area id's for walkable triangles.
See the #rcConfig documentation for more information on the configuration parameters.

@see rcHeightfield, rcClearUnwalkableTriangles, rcRasterizeTriangles

	recast

@param context The build context to use during the operation.
@param walkableSlopeAngle The maximum slope that is considered walkable.
[Limits: 0
<
= value
<
90] [Units: Degrees]
@param verts The vertices. [(x, y, z) * @p nv]
@param numVerts The number of vertices.
@param tris The triangle vertex indices. [(vertA, vertB, vertC) * @p nt]
@param numTris The number of triangles.
@param triAreaIDs The triangle area ids. [Length: >= @p nt]

void rcClearUnwalkableTriangles(rcContext * context, float walkableSlopeAngle, float const * verts, int numVerts, int const * tris, int numTris, unsigned char * triAreaIDs)
*/
func RcClearUnwalkableTriangles(context RcContextPtr, walkableSlopeAngle float32, verts *float32, numVerts int32, tris *int32, numTris int32, triAreaIDs *uint8) {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_walkableSlopeAngle C.float
	var wrap_arg_verts unsafe.Pointer
	var wrap_arg_numVerts C.int
	var wrap_arg_tris unsafe.Pointer
	var wrap_arg_numTris C.int
	var wrap_arg_triAreaIDs unsafe.Pointer
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_walkableSlopeAngle = (C.float)(walkableSlopeAngle)
	wrap_arg_verts = (unsafe.Pointer)(verts)
	wrap_arg_numVerts = (C.int)(numVerts)
	wrap_arg_tris = (unsafe.Pointer)(tris)
	wrap_arg_numTris = (C.int)(numTris)
	wrap_arg_triAreaIDs = (unsafe.Pointer)(triAreaIDs)
	C.nav_rcClearUnwalkableTriangles(wrap_arg_context, wrap_arg_walkableSlopeAngle, wrap_arg_verts, wrap_arg_numVerts, wrap_arg_tris, wrap_arg_numTris, wrap_arg_triAreaIDs)
}

/*
Copies the poly mesh data from src to dst.

	recast

@param ctx The build context to use during the operation.
@param src The source mesh to copy from.
@param dst The resulting detail mesh. (Must be pre-allocated, must be empty mesh.)
@returns True if the operation completed successfully.

bool rcCopyPolyMesh(rcContext * ctx, rcPolyMesh const& src, rcPolyMesh& dst)
*/
func RcCopyPolyMesh(ctx RcContextPtr, src RcPolyMeshPtr, dst RcPolyMeshPtr) bool {
	var wrap_arg_ctx unsafe.Pointer
	var wrap_arg_src unsafe.Pointer
	var wrap_arg_dst unsafe.Pointer
	wrap_arg_ctx = (unsafe.Pointer)(ctx)
	wrap_arg_src = (unsafe.Pointer)(src)
	wrap_arg_dst = (unsafe.Pointer)(dst)
	wrap_out := C.nav_rcCopyPolyMesh(wrap_arg_ctx, wrap_arg_src, wrap_arg_dst)
	go_out := bool(wrap_out)
	return go_out
}

/*
Initializes a new heightfield.
See the #rcConfig documentation for more information on the configuration parameters.

@see rcAllocHeightfield, rcHeightfield

	recast

@param context The build context to use during the operation.
@param heightfield The allocated heightfield to initialize.
@param sizeX The width of the field along the x-axis. [Limit: >= 0] [Units: vx]
@param sizeZ The height of the field along the z-axis. [Limit: >= 0] [Units: vx]
@param minBounds The minimum bounds of the field's AABB. [(x, y, z)] [Units: wu]
@param maxBounds The maximum bounds of the field's AABB. [(x, y, z)] [Units: wu]
@param cellSize The xz-plane cell size to use for the field. [Limit: > 0] [Units: wu]
@param cellHeight The y-axis cell size to use for field. [Limit: > 0] [Units: wu]
@returns True if the operation completed successfully.

bool rcCreateHeightfield(rcContext * context, rcHeightfield& heightfield, int sizeX, int sizeZ, float const * minBounds, float const * maxBounds, float cellSize, float cellHeight)
*/
func RcCreateHeightfield(context RcContextPtr, heightfield RcHeightfieldPtr, sizeX int32, sizeZ int32, minBounds *float32, maxBounds *float32, cellSize float32, cellHeight float32) bool {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_heightfield unsafe.Pointer
	var wrap_arg_sizeX C.int
	var wrap_arg_sizeZ C.int
	var wrap_arg_minBounds unsafe.Pointer
	var wrap_arg_maxBounds unsafe.Pointer
	var wrap_arg_cellSize C.float
	var wrap_arg_cellHeight C.float
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_heightfield = (unsafe.Pointer)(heightfield)
	wrap_arg_sizeX = (C.int)(sizeX)
	wrap_arg_sizeZ = (C.int)(sizeZ)
	wrap_arg_minBounds = (unsafe.Pointer)(minBounds)
	wrap_arg_maxBounds = (unsafe.Pointer)(maxBounds)
	wrap_arg_cellSize = (C.float)(cellSize)
	wrap_arg_cellHeight = (C.float)(cellHeight)
	wrap_out := C.nav_rcCreateHeightfield(wrap_arg_context, wrap_arg_heightfield, wrap_arg_sizeX, wrap_arg_sizeZ, wrap_arg_minBounds, wrap_arg_maxBounds, wrap_arg_cellSize, wrap_arg_cellHeight)
	go_out := bool(wrap_out)
	return go_out
}

/*
Erodes the walkable area within the heightfield by the specified radius.
Basically, any spans that are closer to a boundary or obstruction than the specified radius
are marked as un-walkable.
This method is usually called immediately after the heightfield has been built.

@see rcCompactHeightfield, rcBuildCompactHeightfield, rcConfig::walkableRadius

	recast

@param context The build context to use during the operation.
@param erosionRadius The radius of erosion. [Limits: 0
<
value
<
255] [Units: vx]
@param compactHeightfield The populated compact heightfield to erode.
@returns True if the operation completed successfully.

bool rcErodeWalkableArea(rcContext * context, int erosionRadius, rcCompactHeightfield& compactHeightfield)
*/
func RcErodeWalkableArea(context RcContextPtr, erosionRadius int32, compactHeightfield RcCompactHeightfieldPtr) bool {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_erosionRadius C.int
	var wrap_arg_compactHeightfield unsafe.Pointer
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_erosionRadius = (C.int)(erosionRadius)
	wrap_arg_compactHeightfield = (unsafe.Pointer)(compactHeightfield)
	wrap_out := C.nav_rcErodeWalkableArea(wrap_arg_context, wrap_arg_erosionRadius, wrap_arg_compactHeightfield)
	go_out := bool(wrap_out)
	return go_out
}

/*
Marks spans that are ledges as not-walkable.
A ledge is a span with one or more neighbors whose maximum is further away than @p walkableClimb from the current span's maximum.
This method removes the impact of the overestimation of conservative voxelization
so the resulting mesh will not have regions hanging in the air over ledges.
A span is a ledge if: <tt>rcAbs(currentSpan.smax - neighborSpan.smax) > walkableClimb<tt>

@see rcHeightfield, rcConfig

	recast

@param context The build context to use during the operation.
@param walkableHeight Minimum floor to 'ceiling' height that will still allow the floor area to
be considered walkable. [Limit: >= 3] [Units: vx]
@param walkableClimb Maximum ledge height that is considered to still be traversable.
[Limit: >=0] [Units: vx]
@param heightfield A fully built heightfield.  (All spans have been added.)

void rcFilterLedgeSpans(rcContext * context, int walkableHeight, int walkableClimb, rcHeightfield& heightfield)
*/
func RcFilterLedgeSpans(context RcContextPtr, walkableHeight int32, walkableClimb int32, heightfield RcHeightfieldPtr) {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_walkableHeight C.int
	var wrap_arg_walkableClimb C.int
	var wrap_arg_heightfield unsafe.Pointer
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_walkableHeight = (C.int)(walkableHeight)
	wrap_arg_walkableClimb = (C.int)(walkableClimb)
	wrap_arg_heightfield = (unsafe.Pointer)(heightfield)
	C.nav_rcFilterLedgeSpans(wrap_arg_context, wrap_arg_walkableHeight, wrap_arg_walkableClimb, wrap_arg_heightfield)
}

/*
Marks non-walkable spans as walkable if their maximum is within @p walkableClimb of the span below them.
This removes small obstacles and rasterization artifacts that the agent would be able to walk over
such as curbs.  It also allows agents to move up terraced structures like stairs.
Obstacle spans are marked walkable if: <tt>obstacleSpan.smax - walkableSpan.smax
<
walkableClimb<tt>

@warning Will override the effect of #rcFilterLedgeSpans.  If both filters are used, call #rcFilterLedgeSpans only after applying this filter.

@see rcHeightfield, rcConfig

	recast

@param context The build context to use during the operation.
@param walkableClimb Maximum ledge height that is considered to still be traversable.
[Limit: >=0] [Units: vx]
@param heightfield A fully built heightfield.  (All spans have been added.)

void rcFilterLowHangingWalkableObstacles(rcContext * context, int walkableClimb, rcHeightfield& heightfield)
*/
func RcFilterLowHangingWalkableObstacles(context RcContextPtr, walkableClimb int32, heightfield RcHeightfieldPtr) {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_walkableClimb C.int
	var wrap_arg_heightfield unsafe.Pointer
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_walkableClimb = (C.int)(walkableClimb)
	wrap_arg_heightfield = (unsafe.Pointer)(heightfield)
	C.nav_rcFilterLowHangingWalkableObstacles(wrap_arg_context, wrap_arg_walkableClimb, wrap_arg_heightfield)
}

/*
Marks walkable spans as not walkable if the clearance above the span is less than the specified walkableHeight.
For this filter, the clearance above the span is the distance from the span's
maximum to the minimum of the next higher span in the same column.
If there is no higher span in the column, the clearance is computed as the
distance from the top of the span to the maximum heightfield height.

@see rcHeightfield, rcConfig

	recast

@param context The build context to use during the operation.
@param walkableHeight Minimum floor to 'ceiling' height that will still allow the floor area to
be considered walkable. [Limit: >= 3] [Units: vx]
@param heightfield A fully built heightfield.  (All spans have been added.)

void rcFilterWalkableLowHeightSpans(rcContext * context, int walkableHeight, rcHeightfield& heightfield)
*/
func RcFilterWalkableLowHeightSpans(context RcContextPtr, walkableHeight int32, heightfield RcHeightfieldPtr) {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_walkableHeight C.int
	var wrap_arg_heightfield unsafe.Pointer
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_walkableHeight = (C.int)(walkableHeight)
	wrap_arg_heightfield = (unsafe.Pointer)(heightfield)
	C.nav_rcFilterWalkableLowHeightSpans(wrap_arg_context, wrap_arg_walkableHeight, wrap_arg_heightfield)
}

/*
Frees the specified compact heightfield object using the Recast allocator.

@param compactHeightfield A compact heightfield allocated using #rcAllocCompactHeightfield

	recast

@see rcAllocCompactHeightfield

void rcFreeCompactHeightfield(rcCompactHeightfield * compactHeightfield)
*/
func RcFreeCompactHeightfield(compactHeightfield RcCompactHeightfieldPtr) {
	var wrap_arg_compactHeightfield unsafe.Pointer
	wrap_arg_compactHeightfield = (unsafe.Pointer)(compactHeightfield)
	C.nav_rcFreeCompactHeightfield(wrap_arg_compactHeightfield)
}

/*
Frees the specified contour set using the Recast allocator.

@param contourSet A contour set allocated using #rcAllocContourSet

	recast

@see rcAllocContourSet

void rcFreeContourSet(rcContourSet * contourSet)
*/
func RcFreeContourSet(contourSet RcContourSetPtr) {
	var wrap_arg_contourSet unsafe.Pointer
	wrap_arg_contourSet = (unsafe.Pointer)(contourSet)
	C.nav_rcFreeContourSet(wrap_arg_contourSet)
}

/*
Frees the specified heightfield object using the Recast allocator.

@param heightfield A heightfield allocated using #rcAllocHeightfield

	recast

@see rcAllocHeightfield

void rcFreeHeightField(rcHeightfield * heightfield)
*/
func RcFreeHeightField(heightfield RcHeightfieldPtr) {
	var wrap_arg_heightfield unsafe.Pointer
	wrap_arg_heightfield = (unsafe.Pointer)(heightfield)
	C.nav_rcFreeHeightField(wrap_arg_heightfield)
}

/*
Frees the specified heightfield layer set using the Recast allocator.

@param layerSet A heightfield layer set allocated using #rcAllocHeightfieldLayerSet

	recast

@see rcAllocHeightfieldLayerSet

void rcFreeHeightfieldLayerSet(rcHeightfieldLayerSet * layerSet)
*/
func RcFreeHeightfieldLayerSet(layerSet RcHeightfieldLayerSetPtr) {
	var wrap_arg_layerSet unsafe.Pointer
	wrap_arg_layerSet = (unsafe.Pointer)(layerSet)
	C.nav_rcFreeHeightfieldLayerSet(wrap_arg_layerSet)
}

/*
Frees the specified polygon mesh using the Recast allocator.

@param polyMesh A polygon mesh allocated using #rcAllocPolyMesh

	recast

@see rcAllocPolyMesh

void rcFreePolyMesh(rcPolyMesh * polyMesh)
*/
func RcFreePolyMesh(polyMesh RcPolyMeshPtr) {
	var wrap_arg_polyMesh unsafe.Pointer
	wrap_arg_polyMesh = (unsafe.Pointer)(polyMesh)
	C.nav_rcFreePolyMesh(wrap_arg_polyMesh)
}

/*
Frees the specified detail mesh using the Recast allocator.

@param detailMesh A detail mesh allocated using #rcAllocPolyMeshDetail

	recast

@see rcAllocPolyMeshDetail

void rcFreePolyMeshDetail(rcPolyMeshDetail * detailMesh)
*/
func RcFreePolyMeshDetail(detailMesh RcPolyMeshDetailPtr) {
	var wrap_arg_detailMesh unsafe.Pointer
	wrap_arg_detailMesh = (unsafe.Pointer)(detailMesh)
	C.nav_rcFreePolyMeshDetail(wrap_arg_detailMesh)
}

/*
Gets neighbor connection data for the specified direction.

@param span The span to check.
@param direction The direction to check. [Limits: 0
<
= value
<
4]
@return The neighbor connection data for the specified direction, or #RC_NOT_CONNECTED if there is no connection.

int rcGetCon(rcCompactSpan const& span, int direction)
*/
func RcGetCon(span RcCompactSpanPtr, direction int32) int32 {
	var wrap_arg_span unsafe.Pointer
	var wrap_arg_direction C.int
	wrap_arg_span = (unsafe.Pointer)(span)
	wrap_arg_direction = (C.int)(direction)
	wrap_out := C.nav_rcGetCon(wrap_arg_span, wrap_arg_direction)
	go_out := int32(wrap_out)
	return go_out
}

/*
Gets the direction for the specified offset. One of x and y should be 0.

@param offsetX The x offset. [Limits: -1
<
= value
<
= 1]
@param offsetZ The z offset. [Limits: -1
<
= value
<
= 1]
@return The direction that represents the offset.

int rcGetDirForOffset(int offsetX, int offsetZ)
*/
func RcGetDirForOffset(offsetX int32, offsetZ int32) int32 {
	var wrap_arg_offsetX C.int
	var wrap_arg_offsetZ C.int
	wrap_arg_offsetX = (C.int)(offsetX)
	wrap_arg_offsetZ = (C.int)(offsetZ)
	wrap_out := C.nav_rcGetDirForOffset(wrap_arg_offsetX, wrap_arg_offsetZ)
	go_out := int32(wrap_out)
	return go_out
}

/*
Gets the standard width (x-axis) offset for the specified direction.

@param direction The direction. [Limits: 0
<
= value
<
4]
@return The width offset to apply to the current cell position to move in the direction.

int rcGetDirOffsetX(int direction)
*/
func RcGetDirOffsetX(direction int32) int32 {
	var wrap_arg_direction C.int
	wrap_arg_direction = (C.int)(direction)
	wrap_out := C.nav_rcGetDirOffsetX(wrap_arg_direction)
	go_out := int32(wrap_out)
	return go_out
}

/*
TODO (graham): Rename this to rcGetDirOffsetZ
Gets the standard height (z-axis) offset for the specified direction.

@param direction The direction. [Limits: 0
<
= value
<
4]
@return The height offset to apply to the current cell position to move in the direction.

int rcGetDirOffsetY(int direction)
*/
func RcGetDirOffsetY(direction int32) int32 {
	var wrap_arg_direction C.int
	wrap_arg_direction = (C.int)(direction)
	wrap_out := C.nav_rcGetDirOffsetY(wrap_arg_direction)
	go_out := int32(wrap_out)
	return go_out
}

/*
Returns the number of spans contained in the specified heightfield.

	recast

@param context The build context to use during the operation.
@param heightfield An initialized heightfield.
@returns The number of spans in the heightfield.

int rcGetHeightFieldSpanCount(rcContext * context, rcHeightfield const& heightfield)
*/
func RcGetHeightFieldSpanCount(context RcContextPtr, heightfield RcHeightfieldPtr) int32 {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_heightfield unsafe.Pointer
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_heightfield = (unsafe.Pointer)(heightfield)
	wrap_out := C.nav_rcGetHeightFieldSpanCount(wrap_arg_context, wrap_arg_heightfield)
	go_out := int32(wrap_out)
	return go_out
}

/*
Applies an area id to all spans within the specified bounding box. (AABB)

@see rcCompactHeightfield, rcMedianFilterWalkableArea

	recast

@param context The build context to use during the operation.
@param boxMinBounds The minimum extents of the bounding box. [(x, y, z)] [Units: wu]
@param boxMaxBounds The maximum extents of the bounding box. [(x, y, z)] [Units: wu]
@param areaId The area id to apply. [Limit:
<
= #RC_WALKABLE_AREA]
@param compactHeightfield A populated compact heightfield.

void rcMarkBoxArea(rcContext * context, float const * boxMinBounds, float const * boxMaxBounds, unsigned char areaId, rcCompactHeightfield& compactHeightfield)
*/
func RcMarkBoxArea(context RcContextPtr, boxMinBounds *float32, boxMaxBounds *float32, areaId uint8, compactHeightfield RcCompactHeightfieldPtr) {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_boxMinBounds unsafe.Pointer
	var wrap_arg_boxMaxBounds unsafe.Pointer
	var wrap_arg_areaId C.uchar
	var wrap_arg_compactHeightfield unsafe.Pointer
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_boxMinBounds = (unsafe.Pointer)(boxMinBounds)
	wrap_arg_boxMaxBounds = (unsafe.Pointer)(boxMaxBounds)
	wrap_arg_areaId = (C.uchar)(areaId)
	wrap_arg_compactHeightfield = (unsafe.Pointer)(compactHeightfield)
	C.nav_rcMarkBoxArea(wrap_arg_context, wrap_arg_boxMinBounds, wrap_arg_boxMaxBounds, wrap_arg_areaId, wrap_arg_compactHeightfield)
}

/*
Applies the area id to the all spans within the specified convex polygon.
The value of spacial parameters are in world units.
The y-values of the polygon vertices are ignored. So the polygon is effectively
projected onto the xz-plane, translated to @p minY, and extruded to @p maxY.
@see rcCompactHeightfield, rcMedianFilterWalkableArea

	recast

@param context The build context to use during the operation.
@param verts The vertices of the polygon [For: (x, y, z) * @p numVerts]
@param numVerts The number of vertices in the polygon.
@param minY The height of the base of the polygon. [Units: wu]
@param maxY The height of the top of the polygon. [Units: wu]
@param areaId The area id to apply. [Limit:
<
= #RC_WALKABLE_AREA]
@param compactHeightfield A populated compact heightfield.

void rcMarkConvexPolyArea(rcContext * context, float const * verts, int numVerts, float minY, float maxY, unsigned char areaId, rcCompactHeightfield& compactHeightfield)
*/
func RcMarkConvexPolyArea(context RcContextPtr, verts *float32, numVerts int32, minY float32, maxY float32, areaId uint8, compactHeightfield RcCompactHeightfieldPtr) {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_verts unsafe.Pointer
	var wrap_arg_numVerts C.int
	var wrap_arg_minY C.float
	var wrap_arg_maxY C.float
	var wrap_arg_areaId C.uchar
	var wrap_arg_compactHeightfield unsafe.Pointer
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_verts = (unsafe.Pointer)(verts)
	wrap_arg_numVerts = (C.int)(numVerts)
	wrap_arg_minY = (C.float)(minY)
	wrap_arg_maxY = (C.float)(maxY)
	wrap_arg_areaId = (C.uchar)(areaId)
	wrap_arg_compactHeightfield = (unsafe.Pointer)(compactHeightfield)
	C.nav_rcMarkConvexPolyArea(wrap_arg_context, wrap_arg_verts, wrap_arg_numVerts, wrap_arg_minY, wrap_arg_maxY, wrap_arg_areaId, wrap_arg_compactHeightfield)
}

/*
Applies the area id to all spans within the specified y-axis-aligned cylinder.

@see rcCompactHeightfield, rcMedianFilterWalkableArea

	recast

@param context The build context to use during the operation.
@param position The center of the base of the cylinder. [Form: (x, y, z)] [Units: wu]
@param radius The radius of the cylinder. [Units: wu] [Limit: > 0]
@param height The height of the cylinder. [Units: wu] [Limit: > 0]
@param areaId The area id to apply. [Limit:
<
= #RC_WALKABLE_AREA]
@param compactHeightfield A populated compact heightfield.

void rcMarkCylinderArea(rcContext * context, float const * position, float radius, float height, unsigned char areaId, rcCompactHeightfield& compactHeightfield)
*/
func RcMarkCylinderArea(context RcContextPtr, position *float32, radius float32, height float32, areaId uint8, compactHeightfield RcCompactHeightfieldPtr) {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_position unsafe.Pointer
	var wrap_arg_radius C.float
	var wrap_arg_height C.float
	var wrap_arg_areaId C.uchar
	var wrap_arg_compactHeightfield unsafe.Pointer
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_position = (unsafe.Pointer)(position)
	wrap_arg_radius = (C.float)(radius)
	wrap_arg_height = (C.float)(height)
	wrap_arg_areaId = (C.uchar)(areaId)
	wrap_arg_compactHeightfield = (unsafe.Pointer)(compactHeightfield)
	C.nav_rcMarkCylinderArea(wrap_arg_context, wrap_arg_position, wrap_arg_radius, wrap_arg_height, wrap_arg_areaId, wrap_arg_compactHeightfield)
}

/*
Sets the area id of all triangles with a slope below the specified value
to #RC_WALKABLE_AREA.
Only sets the area id's for the walkable triangles.  Does not alter the
area id's for un-walkable triangles.
See the #rcConfig documentation for more information on the configuration parameters.

@see rcHeightfield, rcClearUnwalkableTriangles, rcRasterizeTriangles

	recast

@param context The build context to use during the operation.
@param walkableSlopeAngle The maximum slope that is considered walkable.
[Limits: 0
<
= value
<
90] [Units: Degrees]
@param verts The vertices. [(x, y, z) * @p nv]
@param numVerts The number of vertices.
@param tris The triangle vertex indices. [(vertA, vertB, vertC) * @p nt]
@param numTris The number of triangles.
@param triAreaIDs The triangle area ids. [Length: >= @p nt]

void rcMarkWalkableTriangles(rcContext * context, float walkableSlopeAngle, float const * verts, int numVerts, int const * tris, int numTris, unsigned char * triAreaIDs)
*/
func RcMarkWalkableTriangles(context RcContextPtr, walkableSlopeAngle float32, verts *float32, numVerts int32, tris *int32, numTris int32, triAreaIDs *uint8) {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_walkableSlopeAngle C.float
	var wrap_arg_verts unsafe.Pointer
	var wrap_arg_numVerts C.int
	var wrap_arg_tris unsafe.Pointer
	var wrap_arg_numTris C.int
	var wrap_arg_triAreaIDs unsafe.Pointer
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_walkableSlopeAngle = (C.float)(walkableSlopeAngle)
	wrap_arg_verts = (unsafe.Pointer)(verts)
	wrap_arg_numVerts = (C.int)(numVerts)
	wrap_arg_tris = (unsafe.Pointer)(tris)
	wrap_arg_numTris = (C.int)(numTris)
	wrap_arg_triAreaIDs = (unsafe.Pointer)(triAreaIDs)
	C.nav_rcMarkWalkableTriangles(wrap_arg_context, wrap_arg_walkableSlopeAngle, wrap_arg_verts, wrap_arg_numVerts, wrap_arg_tris, wrap_arg_numTris, wrap_arg_triAreaIDs)
}

/*
Applies a median filter to walkable area types (based on area id), removing noise.
This filter is usually applied after applying area id's using functions
such as #rcMarkBoxArea, #rcMarkConvexPolyArea, and #rcMarkCylinderArea.

@see rcCompactHeightfield

	recast

@param context The build context to use during the operation.
@param compactHeightfield A populated compact heightfield.
@returns True if the operation completed successfully.

bool rcMedianFilterWalkableArea(rcContext * context, rcCompactHeightfield& compactHeightfield)
*/
func RcMedianFilterWalkableArea(context RcContextPtr, compactHeightfield RcCompactHeightfieldPtr) bool {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_compactHeightfield unsafe.Pointer
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_compactHeightfield = (unsafe.Pointer)(compactHeightfield)
	wrap_out := C.nav_rcMedianFilterWalkableArea(wrap_arg_context, wrap_arg_compactHeightfield)
	go_out := bool(wrap_out)
	return go_out
}

/*
Merges multiple detail meshes into a single detail mesh.

	recast

@param ctx The build context to use during the operation.
@param meshes An array of detail meshes to merge. [Size: @p nmeshes]
@param nmeshes The number of detail meshes in the meshes array.
@param mesh The resulting detail mesh. (Must be pre-allocated.)
@returns True if the operation completed successfully.

bool rcMergePolyMeshDetails(rcContext * ctx, rcPolyMeshDetail * * meshes, int const nmeshes, rcPolyMeshDetail& mesh)
*/
func RcMergePolyMeshDetails(ctx RcContextPtr, meshes *RcPolyMeshDetailPtr, nmeshes int32, mesh RcPolyMeshDetailPtr) bool {
	var wrap_arg_ctx unsafe.Pointer
	var wrap_arg_meshes unsafe.Pointer
	var wrap_arg_nmeshes C.int
	var wrap_arg_mesh unsafe.Pointer
	wrap_arg_ctx = (unsafe.Pointer)(ctx)
	wrap_arg_meshes = (unsafe.Pointer)(meshes)
	wrap_arg_nmeshes = (C.int)(nmeshes)
	wrap_arg_mesh = (unsafe.Pointer)(mesh)
	wrap_out := C.nav_rcMergePolyMeshDetails(wrap_arg_ctx, wrap_arg_meshes, wrap_arg_nmeshes, wrap_arg_mesh)
	go_out := bool(wrap_out)
	return go_out
}

/*
Merges multiple polygon meshes into a single mesh.

	recast

@param ctx The build context to use during the operation.
@param meshes An array of polygon meshes to merge. [Size: @p nmeshes]
@param nmeshes The number of polygon meshes in the meshes array.
@param mesh The resulting polygon mesh. (Must be pre-allocated.)
@returns True if the operation completed successfully.

bool rcMergePolyMeshes(rcContext * ctx, rcPolyMesh * * meshes, int const nmeshes, rcPolyMesh& mesh)
*/
func RcMergePolyMeshes(ctx RcContextPtr, meshes *RcPolyMeshPtr, nmeshes int32, mesh RcPolyMeshPtr) bool {
	var wrap_arg_ctx unsafe.Pointer
	var wrap_arg_meshes unsafe.Pointer
	var wrap_arg_nmeshes C.int
	var wrap_arg_mesh unsafe.Pointer
	wrap_arg_ctx = (unsafe.Pointer)(ctx)
	wrap_arg_meshes = (unsafe.Pointer)(meshes)
	wrap_arg_nmeshes = (C.int)(nmeshes)
	wrap_arg_mesh = (unsafe.Pointer)(mesh)
	wrap_out := C.nav_rcMergePolyMeshes(wrap_arg_ctx, wrap_arg_meshes, wrap_arg_nmeshes, wrap_arg_mesh)
	go_out := bool(wrap_out)
	return go_out
}

/*
Expands a convex polygon along its vertex normals by the given offset amount.
Inserts extra vertices to bevel sharp corners.
Helper function to offset convex polygons for rcMarkConvexPolyArea.

	recast

@param verts The vertices of the polygon [Form: (x, y, z) * @p numVerts]
@param numVerts The number of vertices in the polygon.
@param offset How much to offset the polygon by. [Units: wu]
@param outVerts The offset vertices (should hold up to 2 * @p numVerts) [Form: (x, y, z) * return value]
@param maxOutVerts The max number of vertices that can be stored to @p outVerts.
@returns Number of vertices in the offset polygon or 0 if too few vertices in @p outVerts.

int rcOffsetPoly(float const * verts, int numVerts, float offset, float * outVerts, int maxOutVerts)
*/
func RcOffsetPoly(verts *float32, numVerts int32, offset float32, outVerts *float32, maxOutVerts int32) int32 {
	var wrap_arg_verts unsafe.Pointer
	var wrap_arg_numVerts C.int
	var wrap_arg_offset C.float
	var wrap_arg_outVerts unsafe.Pointer
	var wrap_arg_maxOutVerts C.int
	wrap_arg_verts = (unsafe.Pointer)(verts)
	wrap_arg_numVerts = (C.int)(numVerts)
	wrap_arg_offset = (C.float)(offset)
	wrap_arg_outVerts = (unsafe.Pointer)(outVerts)
	wrap_arg_maxOutVerts = (C.int)(maxOutVerts)
	wrap_out := C.nav_rcOffsetPoly(wrap_arg_verts, wrap_arg_numVerts, wrap_arg_offset, wrap_arg_outVerts, wrap_arg_maxOutVerts)
	go_out := int32(wrap_out)
	return go_out
}

/*
Rasterizes a single triangle into the specified heightfield.
Calling this for each triangle in a mesh is less efficient than calling rcRasterizeTriangles
No spans will be added if the triangle does not overlap the heightfield grid.

@see rcHeightfield

	recast

@param context The build context to use during the operation.
@param v0 Triangle vertex 0 [(x, y, z)]
@param v1 Triangle vertex 1 [(x, y, z)]
@param v2 Triangle vertex 2 [(x, y, z)]
@param areaID The area id of the triangle. [Limit:
<
= #RC_WALKABLE_AREA]
@param heightfield An initialized heightfield.
@param flagMergeThreshold The distance where the walkable flag is favored over the non-walkable flag.
[Limit: >= 0] [Units: vx]
@returns True if the operation completed successfully.

bool rcRasterizeTriangle(rcContext * context, float const * v0, float const * v1, float const * v2, unsigned char areaID, rcHeightfield& heightfield, int flagMergeThreshold=1)
*/
func RcRasterizeTriangle(context RcContextPtr, v0 *float32, v1 *float32, v2 *float32, areaID uint8, heightfield RcHeightfieldPtr, flagMergeThreshold int32) bool {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_v0 unsafe.Pointer
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	var wrap_arg_areaID C.uchar
	var wrap_arg_heightfield unsafe.Pointer
	var wrap_arg_flagMergeThreshold C.int
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_v0 = (unsafe.Pointer)(v0)
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	wrap_arg_areaID = (C.uchar)(areaID)
	wrap_arg_heightfield = (unsafe.Pointer)(heightfield)
	wrap_arg_flagMergeThreshold = (C.int)(flagMergeThreshold)
	wrap_out := C.nav_rcRasterizeTriangle(wrap_arg_context, wrap_arg_v0, wrap_arg_v1, wrap_arg_v2, wrap_arg_areaID, wrap_arg_heightfield, wrap_arg_flagMergeThreshold)
	go_out := bool(wrap_out)
	return go_out
}

/*
Rasterizes an indexed triangle mesh into the specified heightfield.
Spans will only be added for triangles that overlap the heightfield grid.

@see rcHeightfield

	recast

@param context The build context to use during the operation.
@param verts The vertices. [(x, y, z) * @p nv]
@param numVerts The number of vertices. (unused) TODO (graham): Remove in next major release
@param tris The triangle indices. [(vertA, vertB, vertC) * @p nt]
@param triAreaIDs The area id's of the triangles. [Limit:
<
= #RC_WALKABLE_AREA] [Size: @p nt]
@param numTris The number of triangles.
@param heightfield An initialized heightfield.
@param flagMergeThreshold The distance where the walkable flag is favored over the non-walkable flag.
[Limit: >= 0] [Units: vx]
@returns True if the operation completed successfully.

bool rcRasterizeTriangles(rcContext * context, float const * verts, int numVerts, int const * tris, unsigned char const * triAreaIDs, int numTris, rcHeightfield& heightfield, int flagMergeThreshold=1)
*/
func RcRasterizeTriangles(context RcContextPtr, verts *float32, numVerts int32, tris *int32, triAreaIDs *uint8, numTris int32, heightfield RcHeightfieldPtr, flagMergeThreshold int32) bool {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_verts unsafe.Pointer
	var wrap_arg_numVerts C.int
	var wrap_arg_tris unsafe.Pointer
	var wrap_arg_triAreaIDs unsafe.Pointer
	var wrap_arg_numTris C.int
	var wrap_arg_heightfield unsafe.Pointer
	var wrap_arg_flagMergeThreshold C.int
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_verts = (unsafe.Pointer)(verts)
	wrap_arg_numVerts = (C.int)(numVerts)
	wrap_arg_tris = (unsafe.Pointer)(tris)
	wrap_arg_triAreaIDs = (unsafe.Pointer)(triAreaIDs)
	wrap_arg_numTris = (C.int)(numTris)
	wrap_arg_heightfield = (unsafe.Pointer)(heightfield)
	wrap_arg_flagMergeThreshold = (C.int)(flagMergeThreshold)
	wrap_out := C.nav_rcRasterizeTriangles(wrap_arg_context, wrap_arg_verts, wrap_arg_numVerts, wrap_arg_tris, wrap_arg_triAreaIDs, wrap_arg_numTris, wrap_arg_heightfield, wrap_arg_flagMergeThreshold)
	go_out := bool(wrap_out)
	return go_out
}

/*
Rasterizes an indexed triangle mesh into the specified heightfield.
Spans will only be added for triangles that overlap the heightfield grid.

@see rcHeightfield

	recast

@param context The build context to use during the operation.
@param verts The vertices. [(x, y, z) * @p nv]
@param numVerts The number of vertices. (unused) TODO (graham): Remove in next major release
@param tris The triangle indices. [(vertA, vertB, vertC) * @p nt]
@param triAreaIDs The area id's of the triangles. [Limit:
<
= #RC_WALKABLE_AREA] [Size: @p nt]
@param numTris The number of triangles.
@param heightfield An initialized heightfield.
@param flagMergeThreshold The distance where the walkable flag is favored over the non-walkable flag.
[Limit: >= 0] [Units: vx]
@returns True if the operation completed successfully.

bool rcRasterizeTriangles(rcContext * context, float const * verts, int numVerts, unsigned short const * tris, unsigned char const * triAreaIDs, int numTris, rcHeightfield& heightfield, int flagMergeThreshold=1)
*/
func RcRasterizeTriangles11(context RcContextPtr, verts *float32, numVerts int32, tris *uint16, triAreaIDs *uint8, numTris int32, heightfield RcHeightfieldPtr, flagMergeThreshold int32) bool {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_verts unsafe.Pointer
	var wrap_arg_numVerts C.int
	var wrap_arg_tris unsafe.Pointer
	var wrap_arg_triAreaIDs unsafe.Pointer
	var wrap_arg_numTris C.int
	var wrap_arg_heightfield unsafe.Pointer
	var wrap_arg_flagMergeThreshold C.int
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_verts = (unsafe.Pointer)(verts)
	wrap_arg_numVerts = (C.int)(numVerts)
	wrap_arg_tris = (unsafe.Pointer)(tris)
	wrap_arg_triAreaIDs = (unsafe.Pointer)(triAreaIDs)
	wrap_arg_numTris = (C.int)(numTris)
	wrap_arg_heightfield = (unsafe.Pointer)(heightfield)
	wrap_arg_flagMergeThreshold = (C.int)(flagMergeThreshold)
	wrap_out := C.nav_rcRasterizeTriangles11(wrap_arg_context, wrap_arg_verts, wrap_arg_numVerts, wrap_arg_tris, wrap_arg_triAreaIDs, wrap_arg_numTris, wrap_arg_heightfield, wrap_arg_flagMergeThreshold)
	go_out := bool(wrap_out)
	return go_out
}

/*
Rasterizes a triangle list into the specified heightfield.
Expects each triangle to be specified as three sequential vertices of 3 floats.
Spans will only be added for triangles that overlap the heightfield grid.

@see rcHeightfield

	recast

@param context The build context to use during the operation.
@param verts The triangle vertices. [(ax, ay, az, bx, by, bz, cx, by, cx) * @p nt]
@param triAreaIDs The area id's of the triangles. [Limit:
<
= #RC_WALKABLE_AREA] [Size: @p nt]
@param numTris The number of triangles.
@param heightfield An initialized heightfield.
@param flagMergeThreshold The distance where the walkable flag is favored over the non-walkable flag.
[Limit: >= 0] [Units: vx]
@returns True if the operation completed successfully.

bool rcRasterizeTriangles(rcContext * context, float const * verts, unsigned char const * triAreaIDs, int numTris, rcHeightfield& heightfield, int flagMergeThreshold=1)
*/
func RcRasterizeTriangles12(context RcContextPtr, verts *float32, triAreaIDs *uint8, numTris int32, heightfield RcHeightfieldPtr, flagMergeThreshold int32) bool {
	var wrap_arg_context unsafe.Pointer
	var wrap_arg_verts unsafe.Pointer
	var wrap_arg_triAreaIDs unsafe.Pointer
	var wrap_arg_numTris C.int
	var wrap_arg_heightfield unsafe.Pointer
	var wrap_arg_flagMergeThreshold C.int
	wrap_arg_context = (unsafe.Pointer)(context)
	wrap_arg_verts = (unsafe.Pointer)(verts)
	wrap_arg_triAreaIDs = (unsafe.Pointer)(triAreaIDs)
	wrap_arg_numTris = (C.int)(numTris)
	wrap_arg_heightfield = (unsafe.Pointer)(heightfield)
	wrap_arg_flagMergeThreshold = (C.int)(flagMergeThreshold)
	wrap_out := C.nav_rcRasterizeTriangles12(wrap_arg_context, wrap_arg_verts, wrap_arg_triAreaIDs, wrap_arg_numTris, wrap_arg_heightfield, wrap_arg_flagMergeThreshold)
	go_out := bool(wrap_out)
	return go_out
}

/*
Sets the neighbor connection data for the specified direction.

@param span The span to update.
@param direction The direction to set. [Limits: 0
<
= value
<
4]
@param neighborIndex The index of the neighbor span.

void rcSetCon(rcCompactSpan& span, int direction, int neighborIndex)
*/
func RcSetCon(span RcCompactSpanPtr, direction int32, neighborIndex int32) {
	var wrap_arg_span unsafe.Pointer
	var wrap_arg_direction C.int
	var wrap_arg_neighborIndex C.int
	wrap_arg_span = (unsafe.Pointer)(span)
	wrap_arg_direction = (C.int)(direction)
	wrap_arg_neighborIndex = (C.int)(neighborIndex)
	C.nav_rcSetCon(wrap_arg_span, wrap_arg_direction, wrap_arg_neighborIndex)
}

/*
Returns the square root of the value.

@param x The value.
@return The square root of the vlaue.

float rcSqrt(float x)
*/
func RcSqrt(x float32) float32 {
	var wrap_arg_x C.float
	wrap_arg_x = (C.float)(x)
	wrap_out := C.nav_rcSqrt(wrap_arg_x)
	go_out := float32(wrap_out)
	return go_out
}

/*
Performs a vector addition. (@p v1 + @p v2)
@param dest The result vector. [(x, y, z)]
@param v1 The base vector. [(x, y, z)]
@param v2 The vector to add to @p v1. [(x, y, z)]

void rcVadd(float * dest, float const * v1, float const * v2)
*/
func RcVadd(dest *float32, v1 *float32, v2 *float32) {
	var wrap_arg_dest unsafe.Pointer
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_dest = (unsafe.Pointer)(dest)
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	C.nav_rcVadd(wrap_arg_dest, wrap_arg_v1, wrap_arg_v2)
}

/*
Performs a vector copy.

@param dest The result. [(x, y, z)]
@param v The vector to copy. [(x, y, z)]

void rcVcopy(float * dest, float const * v)
*/
func RcVcopy(dest *float32, v *float32) {
	var wrap_arg_dest unsafe.Pointer
	var wrap_arg_v unsafe.Pointer
	wrap_arg_dest = (unsafe.Pointer)(dest)
	wrap_arg_v = (unsafe.Pointer)(v)
	C.nav_rcVcopy(wrap_arg_dest, wrap_arg_v)
}

/*
Derives the cross product of two vectors. (@p v1 x @p v2)
@param dest The cross product. [(x, y, z)]
@param v1 A Vector [(x, y, z)]
@param v2 A vector [(x, y, z)]

void rcVcross(float * dest, float const * v1, float const * v2)
*/
func RcVcross(dest *float32, v1 *float32, v2 *float32) {
	var wrap_arg_dest unsafe.Pointer
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_dest = (unsafe.Pointer)(dest)
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	C.nav_rcVcross(wrap_arg_dest, wrap_arg_v1, wrap_arg_v2)
}

/*
Returns the distance between two points.

@param v1 A point. [(x, y, z)]
@param v2 A point. [(x, y, z)]
@return The distance between the two points.

float rcVdist(float const * v1, float const * v2)
*/
func RcVdist(v1 *float32, v2 *float32) float32 {
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	wrap_out := C.nav_rcVdist(wrap_arg_v1, wrap_arg_v2)
	go_out := float32(wrap_out)
	return go_out
}

/*
Returns the square of the distance between two points.

@param v1 A point. [(x, y, z)]
@param v2 A point. [(x, y, z)]
@return The square of the distance between the two points.

float rcVdistSqr(float const * v1, float const * v2)
*/
func RcVdistSqr(v1 *float32, v2 *float32) float32 {
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	wrap_out := C.nav_rcVdistSqr(wrap_arg_v1, wrap_arg_v2)
	go_out := float32(wrap_out)
	return go_out
}

/*
Derives the dot product of two vectors. (@p v1 . @p v2)
@param v1 A Vector [(x, y, z)]
@param v2 A vector [(x, y, z)]
@return The dot product.

float rcVdot(float const * v1, float const * v2)
*/
func RcVdot(v1 *float32, v2 *float32) float32 {
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	wrap_out := C.nav_rcVdot(wrap_arg_v1, wrap_arg_v2)
	go_out := float32(wrap_out)
	return go_out
}

/*
Performs a scaled vector addition. (@p v1 + (@p v2 * @p s))
@param dest The result vector. [(x, y, z)]
@param v1 The base vector. [(x, y, z)]
@param v2 The vector to scale and add to @p v1. [(x, y, z)]
@param s The amount to scale @p v2 by before adding to @p v1.

void rcVmad(float * dest, float const * v1, float const * v2, float const s)
*/
func RcVmad(dest *float32, v1 *float32, v2 *float32, s float32) {
	var wrap_arg_dest unsafe.Pointer
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	var wrap_arg_s C.float
	wrap_arg_dest = (unsafe.Pointer)(dest)
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	wrap_arg_s = (C.float)(s)
	C.nav_rcVmad(wrap_arg_dest, wrap_arg_v1, wrap_arg_v2, wrap_arg_s)
}

/*
Selects the maximum value of each element from the specified vectors.

@param mx A vector.  (Will be updated with the result.) [(x, y, z)]
@param v A vector. [(x, y, z)]

void rcVmax(float * mx, float const * v)
*/
func RcVmax(mx *float32, v *float32) {
	var wrap_arg_mx unsafe.Pointer
	var wrap_arg_v unsafe.Pointer
	wrap_arg_mx = (unsafe.Pointer)(mx)
	wrap_arg_v = (unsafe.Pointer)(v)
	C.nav_rcVmax(wrap_arg_mx, wrap_arg_v)
}

/*
Selects the minimum value of each element from the specified vectors.

@param mn A vector.  (Will be updated with the result.) [(x, y, z)]
@param v A vector. [(x, y, z)]

void rcVmin(float * mn, float const * v)
*/
func RcVmin(mn *float32, v *float32) {
	var wrap_arg_mn unsafe.Pointer
	var wrap_arg_v unsafe.Pointer
	wrap_arg_mn = (unsafe.Pointer)(mn)
	wrap_arg_v = (unsafe.Pointer)(v)
	C.nav_rcVmin(wrap_arg_mn, wrap_arg_v)
}

/*
Normalizes the vector.

@param v The vector to normalize. [(x, y, z)]

void rcVnormalize(float * v)
*/
func RcVnormalize(v *float32) {
	var wrap_arg_v unsafe.Pointer
	wrap_arg_v = (unsafe.Pointer)(v)
	C.nav_rcVnormalize(wrap_arg_v)
}

/*
Performs a vector subtraction. (@p v1 - @p v2)
@param dest The result vector. [(x, y, z)]
@param v1 The base vector. [(x, y, z)]
@param v2 The vector to subtract from @p v1. [(x, y, z)]

void rcVsub(float * dest, float const * v1, float const * v2)
*/
func RcVsub(dest *float32, v1 *float32, v2 *float32) {
	var wrap_arg_dest unsafe.Pointer
	var wrap_arg_v1 unsafe.Pointer
	var wrap_arg_v2 unsafe.Pointer
	wrap_arg_dest = (unsafe.Pointer)(dest)
	wrap_arg_v1 = (unsafe.Pointer)(v1)
	wrap_arg_v2 = (unsafe.Pointer)(v2)
	C.nav_rcVsub(wrap_arg_dest, wrap_arg_v1, wrap_arg_v2)
}

/*
Contour build flags.

@see rcBuildContours
*/
type EnumRcBuildContoursFlags uint32

const (
	/*
	   Tessellate solid (impassable) edges during contour simplification.
	*/
	EnumRcBuildContoursFlags_RC_CONTOUR_TESS_WALL_EDGES EnumRcBuildContoursFlags = 1
	/*
	   Tessellate edges between areas during contour simplification.
	*/
	EnumRcBuildContoursFlags_RC_CONTOUR_TESS_AREA_EDGES EnumRcBuildContoursFlags = 2
)

/*
Recast log categories.

@see rcContext
*/
type EnumRcLogCategory uint32

const (
	/*
	   A progress log entry.
	*/
	EnumRcLogCategory_RC_LOG_PROGRESS EnumRcLogCategory = 1
	/*
	   A warning log entry.
	*/
	EnumRcLogCategory_RC_LOG_WARNING EnumRcLogCategory = 2
	/*
	   An error log entry.
	*/
	EnumRcLogCategory_RC_LOG_ERROR EnumRcLogCategory = 3
)

/*
Recast performance timer categories.

@see rcContext
*/
type EnumRcTimerLabel uint32

const (
	/*
	   The user defined total time of the build.
	*/
	EnumRcTimerLabel_RC_TIMER_TOTAL EnumRcTimerLabel = 0
	/*
	   A user defined build time.
	*/
	EnumRcTimerLabel_RC_TIMER_TEMP EnumRcTimerLabel = 1
	/*
	   The time to rasterize the triangles. (See: #rcRasterizeTriangle)
	*/
	EnumRcTimerLabel_RC_TIMER_RASTERIZE_TRIANGLES EnumRcTimerLabel = 2
	/*
	   The time to build the compact heightfield. (See: #rcBuildCompactHeightfield)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_COMPACTHEIGHTFIELD EnumRcTimerLabel = 3
	/*
	   The total time to build the contours. (See: #rcBuildContours)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_CONTOURS EnumRcTimerLabel = 4
	/*
	   The time to trace the boundaries of the contours. (See: #rcBuildContours)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_CONTOURS_TRACE EnumRcTimerLabel = 5
	/*
	   The time to simplify the contours. (See: #rcBuildContours)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_CONTOURS_SIMPLIFY EnumRcTimerLabel = 6
	/*
	   The time to filter ledge spans. (See: #rcFilterLedgeSpans)
	*/
	EnumRcTimerLabel_RC_TIMER_FILTER_BORDER EnumRcTimerLabel = 7
	/*
	   The time to filter low height spans. (See: #rcFilterWalkableLowHeightSpans)
	*/
	EnumRcTimerLabel_RC_TIMER_FILTER_WALKABLE EnumRcTimerLabel = 8
	/*
	   The time to apply the median filter. (See: #rcMedianFilterWalkableArea)
	*/
	EnumRcTimerLabel_RC_TIMER_MEDIAN_AREA EnumRcTimerLabel = 9
	/*
	   The time to filter low obstacles. (See: #rcFilterLowHangingWalkableObstacles)
	*/
	EnumRcTimerLabel_RC_TIMER_FILTER_LOW_OBSTACLES EnumRcTimerLabel = 10
	/*
	   The time to build the polygon mesh. (See: #rcBuildPolyMesh)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_POLYMESH EnumRcTimerLabel = 11
	/*
	   The time to merge polygon meshes. (See: #rcMergePolyMeshes)
	*/
	EnumRcTimerLabel_RC_TIMER_MERGE_POLYMESH EnumRcTimerLabel = 12
	/*
	   The time to erode the walkable area. (See: #rcErodeWalkableArea)
	*/
	EnumRcTimerLabel_RC_TIMER_ERODE_AREA EnumRcTimerLabel = 13
	/*
	   The time to mark a box area. (See: #rcMarkBoxArea)
	*/
	EnumRcTimerLabel_RC_TIMER_MARK_BOX_AREA EnumRcTimerLabel = 14
	/*
	   The time to mark a cylinder area. (See: #rcMarkCylinderArea)
	*/
	EnumRcTimerLabel_RC_TIMER_MARK_CYLINDER_AREA EnumRcTimerLabel = 15
	/*
	   The time to mark a convex polygon area. (See: #rcMarkConvexPolyArea)
	*/
	EnumRcTimerLabel_RC_TIMER_MARK_CONVEXPOLY_AREA EnumRcTimerLabel = 16
	/*
	   The total time to build the distance field. (See: #rcBuildDistanceField)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD EnumRcTimerLabel = 17
	/*
	   The time to build the distances of the distance field. (See: #rcBuildDistanceField)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_DIST EnumRcTimerLabel = 18
	/*
	   The time to blur the distance field. (See: #rcBuildDistanceField)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_DISTANCEFIELD_BLUR EnumRcTimerLabel = 19
	/*
	   The total time to build the regions. (See: #rcBuildRegions, #rcBuildRegionsMonotone)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_REGIONS EnumRcTimerLabel = 20
	/*
	   The total time to apply the watershed algorithm. (See: #rcBuildRegions)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_REGIONS_WATERSHED EnumRcTimerLabel = 21
	/*
	   The time to expand regions while applying the watershed algorithm. (See: #rcBuildRegions)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_REGIONS_EXPAND EnumRcTimerLabel = 22
	/*
	   The time to flood regions while applying the watershed algorithm. (See: #rcBuildRegions)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_REGIONS_FLOOD EnumRcTimerLabel = 23
	/*
	   The time to filter out small regions. (See: #rcBuildRegions, #rcBuildRegionsMonotone)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_REGIONS_FILTER EnumRcTimerLabel = 24
	/*
	   The time to build heightfield layers. (See: #rcBuildHeightfieldLayers)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_LAYERS EnumRcTimerLabel = 25
	/*
	   The time to build the polygon mesh detail. (See: #rcBuildPolyMeshDetail)
	*/
	EnumRcTimerLabel_RC_TIMER_BUILD_POLYMESHDETAIL EnumRcTimerLabel = 26
	/*
	   The time to merge polygon mesh details. (See: #rcMergePolyMeshDetails)
	*/
	EnumRcTimerLabel_RC_TIMER_MERGE_POLYMESHDETAIL EnumRcTimerLabel = 27
	/*
	   The maximum number of timers.  (Used for iterating timers.)
	*/
	EnumRcTimerLabel_RC_MAX_TIMERS EnumRcTimerLabel = 28
)
